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/actions/load_toolchain/action.yml b/.github/actions/load_toolchain/action.yml
new file mode 100644
index 0000000000..544599b3e0
--- /dev/null
+++ b/.github/actions/load_toolchain/action.yml
@@ -0,0 +1,16 @@
+name: Load Rust Toolchain
+description: Load Rust toolchain from rust-toolchain file
+outputs:
+  rust_toolchain:
+    description: The loaded Rust toolchain
+    value: ${{ steps.load_toolchain.outputs.rust_toolchain }}
+runs:
+  using: composite
+  steps:
+    - name: Load toolchain
+      id: load_toolchain
+      shell: sh
+      run: |
+        # TODO: Actually parse this from Cargo.toml
+        rust_toolchain=$(head -n1 rust-toolchain | tr -d '\n')
+        echo "rust_toolchain=$rust_toolchain" >> $GITHUB_OUTPUT
\ No newline at end of file
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000000..9a77dc8521
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,50 @@
+# GitHub Copilot Instructions
+
+## Code Writing Standards
+- Follow established code-writing standards for your language (spacing, comments, naming).
+- Consider internal coding rules for folder and function naming.
+- Follow the "boy scout rule": Always leave the codebase cleaner than you found it.
+
+## Comment Usage
+- Use comments sparingly and make them meaningful.
+- Avoid commenting on obvious things; use comments to explain "why" or unusual behavior.
+
+## Conditional Encapsulation
+- Encapsulate nested if/else statements into functions with descriptive names for clarity.
+
+## DRY Principle
+- Avoid code duplication; reuse code via functions, classes, modules, or libraries.
+- Modify code in one place if updates are needed.
+
+## Function Length & Responsibility
+- Write short, focused functions (single responsibility principle).
+- Break up long or complex functions into smaller ones.
+
+## General Code Style & Readability
+- Write readable, understandable, and maintainable code.
+- Prioritize clarity and adhere to coding standards.
+- Regularly review and refactor code for structure and maintainability.
+- Use version control (e.g., Git) for collaboration.
+
+## Naming Conventions
+- Use meaningful, descriptive names for variables, functions, and classes.
+- Names should reflect purpose and behavior; avoid names that require comments to explain intent.
+
+## Making your changes pass CI
+- Before submitting any changes
+  - Run the commands for formatting
+  - Run the linter command shown below
+  - Run tests for code you changed and everything that depends on it.
+- CI will reject code with formatting or linting issues.
+
+## Useful commands:
+- Format the code: `cargo fmt`
+- Lint and fix common mistakes: `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 " cargo clippy --all --exclude wasmer-swift --locked --fix --allow-dirty -- -D clippy::all`
+- Build the cli: `cargo build -p wasmer-cli --features cranelift,llvm,wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load`
+- Test the cli: `cargo test -p wasmer-cli --features cranelift,llvm,wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load`
+- Test WASIX: `cargo test -p wasmer-wasix --features sys`
+- Convert a wasm module to wat (always limit the output with head/grep/tail): `wasm-tools print file.wasm`
+- Convert a wat module to wasm: `wasm-tools parse file.wat -o file.wasm`
+- For really hard debugging, creduce is available
+- Optimize a wasm module and strip debug info: `wasm-opt -O3 file.wasm -o file.opt.wasm`
+- Compile a C file to a WASIX module: `WASIXCC_WASM_EXCEPTIONS=1 WASIXCC_PIC=1 wasixcc -g -O0 file.c -o file.wasm`
\ No newline at end of file
diff --git a/.github/cross-linux-riscv64/Dockerfile b/.github/cross-linux-riscv64/Dockerfile
index 47eb4b6e5d..3f1402f2f5 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.91
 # add docker the manual way
 COPY install_docker.sh /
 RUN /install_docker.sh
@@ -61,10 +61,16 @@ 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.91-x86_64-unknown-linux-gnu
+
+# quickly install cargo nextest by using pre-built binary
+RUN curl -LsSf https://get.nexte.st/latest/linux | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin
 
 #compile libssl-dev for riscv64!
 COPY build_openssl.sh /
 RUN /build_openssl.sh
 ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR=/openssl_riscv64/include
 ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR=/openssl_riscv64/lib
+
+RUN mkdir .cargo
+COPY config.toml .cargo/config.toml
diff --git a/.github/cross-linux-riscv64/config.toml b/.github/cross-linux-riscv64/config.toml
new file mode 100644
index 0000000000..ca24481ff4
--- /dev/null
+++ b/.github/cross-linux-riscv64/config.toml
@@ -0,0 +1,3 @@
+[target.riscv64gc-unknown-linux-gnu]
+linker = "riscv64-linux-gnu-gcc"
+runner = "qemu-riscv64 -L /usr/riscv64-linux-gnu/"
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..c276ac4222 100644
--- a/.github/workflows/benchmark.yaml
+++ b/.github/workflows/benchmark.yaml
@@ -3,11 +3,10 @@ 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"
 
 jobs:
   run_benchmark:
@@ -20,15 +19,14 @@ jobs:
         include:
           - build: linux
             os: ubuntu-latest
-    env:
-      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
-      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
       - name: Configure cargo data directory
         # After this point, all cargo registry and crate data is stored in
         # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files
@@ -53,7 +51,7 @@ jobs:
       - name: Install LLVM (Linux)
         if: matrix.os == 'ubuntu-latest'
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04.tar.xz -L -o llvm.tar.xz
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04.tar.xz -L -o llvm.tar.xz
           mkdir -p /opt/llvm-10
           tar xf llvm.tar.xz --strip-components=1 -C /opt/llvm-10
           echo '/opt/llvm-10/bin' >> $GITHUB_PATH
@@ -72,4 +70,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..ba5fdaae2f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -3,19 +3,22 @@ name: Builds
 env:
   RUST_BACKTRACE: 1
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.74"
 
 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
@@ -36,118 +39,165 @@ jobs:
           echo $DOING_RELEASE
 
   build:
-    name: Build on ${{ matrix.build }}
+    name: ${{ 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/21.x/llvm-linux-aarch64.tar.xz"
+            cross_compilation_artifact_name: "cross_compiled_from_linux"
+            build_wasm: true
+            enable_llvm: true
+            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'
-            use_sccache: false
-            use_llvm: true
+            os: ubuntu-22.04
+            artifact_name: "wasmer-linux-amd64"
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-amd64.tar.xz"
+            cross_compilation_artifact_name: "cross_compiled_from_linux"
             build_wasm: true
+            enable_llvm: true
+            # V8 issue broken right now: https://github.com/wasmerio/wasmer/pull/6124
+            enable_v8: false
+            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'
-            use_sccache: false
-            use_llvm: true
+            os: macos-15-intel
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-amd64.tar.xz"
+            artifact_name: "wasmer-darwin-amd64"
+            cross_compilation_artifact_name: "cross_compiled_from_mac"
             build_wasm: false
+            enable_llvm: true
+            # V8 issue broken right now: https://github.com/wasmerio/wasmer/pull/6124
+            enable_v8: false
+            enable_wasmi: true
+            enable_wamr: true
           - build: macos-arm64
-            os: macos-14
+            os: depot-macos-14
             target: aarch64-apple-darwin
-            artifact_name: 'wasmer-darwin-arm64'
-            use_sccache: false
-            use_llvm: false
+            artifact_name: "wasmer-darwin-arm64"
             build_wasm: false
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-aarch64.tar.xz"
+            enable_llvm: true
+            # V8 issue broken right now: https://github.com/wasmerio/wasmer/pull/6124
+            enable_v8: false
+            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/21.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
-    container: ${{ matrix.container }}
+            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
+            #  enable_llvm: false
+            #  enable_v8: false
+            #  enable_wasmi: true
+            #  enable_wamr: false
+
     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@v6
       - 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 make curl cmake ninja clang21 zstd-static llvm21-dev clang21-static llvm21-static ncurses-static zlib-static libxml2-dev libxml2-static xz-dev xz-static xz-libs libc++-dev libc++-static
+          ln -s /usr/bin/clang-21 /usr/bin/clang
+      - name: Install Linux tools
+        if: startsWith(matrix.build, 'linux-x64')
+        run: |
+          sudo apt install ninja-build
+      - name: Install Linux ARM tools
+        if: startsWith(matrix.build, 'linux-arm64')
+        run: |
+          sudo apt install 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-')
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - 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
-      - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.os == 'macos-12' && !matrix.llvm_url
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
+          target: ${{ matrix.target }}      
+      - name: Install LLVM (macOS Intel)
+        if: matrix.os == 'macos-15-intel' && !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 }}
           mkdir -p ${LLVM_DIR}
-          curl --proto '=https' --tlsv1.2 -sSf "${{ matrix.llvm_url }}" -L -o - | tar xJv -C ${LLVM_DIR}
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf "${{ matrix.llvm_url }}" -L -o - | tar xJv -C ${LLVM_DIR}
           echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
         env:
           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_211_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' || matrix.os == 'depot-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
-        if: matrix.use_sccache
-        with:
-          path: ${{ runner.tool_cache }}/cargo-sccache
-          key: ${{ matrix.build }}-${{ matrix.target }}-sccache-bin-${{ env.CARGO_SCCACHE_VERSION }}-v1
-      - name: Install sccache
-        if: matrix.use_sccache
-        run: |
-          if [ ! -f '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' ]; then
-            cargo install sccache --no-default-features --features=dist-client,azure --root '${{ runner.tool_cache }}/cargo-sccache'
-          fi
-        shell: bash
       - name: Setup Rust target
         run: |
           mkdir -p .cargo
@@ -156,70 +206,65 @@ jobs:
           target = "${{ matrix.target }}"
           EOF
         if: matrix.target
-      - name: Set sccache port
-        if: matrix.use_sccache && matrix.random_sccache_port
-        run: |
-          netstat -aln | awk '
-            $6 == "LISTEN" {
-              if ($4 ~ "[.:][0-9]+$") {
-                n = split($4, a, /[:.]/);
-                port = a[n];
-                p[port] = 1
-              }
-            }
-            END {
-              for (i = 3000; i < 65000 && p[i]; i++){};
-              if (i == 65000) {exit 1};
-              print "SCCACHE_SERVER_PORT=" i
-            }
-          ' >> $GITHUB_ENV
-          # echo "SCCACHE_SERVER_PORT=9000"
-          echo "Setting random sccache port to: $SCCACHE_SERVER_PORT"
-        shell: bash
-      - name: Start sccache
-        if: matrix.use_sccache
-        run: |
-          chmod +x '${{ runner.tool_cache }}/cargo-sccache/bin/sccache'
-          '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' --start-server
-          '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' -s
-          echo 'RUSTC_WRAPPER=${{ runner.tool_cache }}/cargo-sccache/bin/sccache' >> $GITHUB_ENV
-        shell: bash
       - name: Build C API headless
         shell: bash
         run: |
-          make package-capi-headless
+          LLVM_CONFIG_PATH=/usr/bin/llvm-config-21 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-21 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
+          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: |
           make build-wasmer
-     #- name: Build Wasmer binary on Wasm32-WASI without LLVM
-     #  if: matrix.build_wasm
-     #  shell: bash
-     #  run: |
-     #    make build-wasmer-wasm
+        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-21 "$@" "--link-static"' >> /usr/bin/llvm-config
+          echo "else" >> /usr/bin/llvm-config
+          echo 'llvm-config-21 "$@"' >> /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=-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 +276,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
@@ -246,10 +289,11 @@ jobs:
           retention-days: 2
 
   windows_gnu:
-    name: 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@v6
       - name: Install Windows-GNU linker
         shell: bash
         run: |
@@ -271,11 +315,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 +350,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
+    name: JSC - macos-aarch64
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
+    runs-on: depot-macos-14
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: aarch64-apple-darwin
@@ -338,18 +384,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
+    name: JSC - macos-x86_64
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
+    runs-on: macos-15-intel
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: x86_64-apple-darwin
@@ -367,83 +414,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
+    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@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: riscv64gc-unknown-linux-gnu
@@ -497,7 +480,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 +488,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 +560,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..d2baaf2a41 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@v6
       - 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..b8119003be 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@v6
         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/cloudcompiler.yaml b/.github/workflows/cloudcompiler.yaml
index 22ac4b1e7d..6fd74edbe9 100644
--- a/.github/workflows/cloudcompiler.yaml
+++ b/.github/workflows/cloudcompiler.yaml
@@ -2,13 +2,12 @@ name: Release cloudcompiler.wasm
 
 env:
   RUST_BACKTRACE: 1
-  MSRV: "1.74"
 
 on:
   push:
     tags:
       # trigger action on release branch
-      - '[0-9]+.[0-9]+.[0-9]+*'
+      - "[0-9]+.[0-9]+.[0-9]+*"
   workflow_dispatch:
 
 jobs:
@@ -16,27 +15,28 @@ jobs:
     name: Set up
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
-          target: ${{ matrix.target }}
-      - name: Install wasm32-wasi target
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
+      - 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/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml
new file mode 100644
index 0000000000..fe60eea928
--- /dev/null
+++ b/.github/workflows/copilot-setup-steps.yml
@@ -0,0 +1,120 @@
+name: "Copilot Setup Steps"
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+env:
+  RUST_BACKTRACE: 1
+
+jobs:
+  # The job MUST be called `copilot-setup-steps`
+  copilot-setup-steps:
+    runs-on: ubuntu-22.04
+
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up libstdc++ on Linux
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --allow-downgrades libstdc++6
+          sudo apt-get install -y --reinstall g++
+          sudo apt-get install -y creduce
+
+      - name: Read rust version
+        id: read_rust_version
+        run: |
+          rust_toolchain=$(head -n1 rust-toolchain | tr -d '\n')
+          echo "MSRV=$rust_toolchain" >> $GITHUB_ENV
+          echo "MSRV=$rust_toolchain" >> $GITHUB_OUTPUT
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ steps.read_rust_version.outputs.MSRV }}
+          target: x86_64-unknown-linux-gnu
+          components: rustc,cargo,rust-std,rust-src,clippy,rustfmt,rust-analyzer,rust-docs
+
+      - name: Cache dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            ~/.wasmer/cache/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+            ${{ runner.os }}-cargo-
+
+      - name: Install Nextest
+        uses: taiki-e/install-action@nextest
+
+      - name: Install LLVM
+        shell: bash
+        run: |
+          cd $HOME
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf ${{ env.LLVM_URL }} -L -o llvm.tar.xz
+          LLVM_DIR=$HOME/.llvm
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
+          cd -
+        env:
+          LLVM_URL: https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-amd64.tar.xz
+
+      - name: Install wasixcc
+        uses: wasix-org/wasixcc@main
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          sysroot-tag: v2025-12-22.1
+
+      - name: Install wasm-tools
+        run: |
+          cargo install --locked wasm-tools
+
+      - name: Ensure the setup works
+        shell: bash
+        run: |
+          # Check rustfmt is installed
+          cargo fmt --version
+          # Check clippy is installed
+          cargo clippy --version
+          # Check wasm-tools is installed
+          wasm-tools --version
+          # Check wasixcc is installed
+          wasixcc --version
+          # Check wasm-opt is available
+          wasm-opt --version
+          # Check that the repo exists
+          git status --porcelain
+          # Check that the repo is clean
+          test -z "$(git status --porcelain)"
+          # Check that clang is installed
+          clang --version
+          # Check that clang comes from the LLVM we installed
+          clang_path=$(which clang)
+          echo "Clang path: $clang_path"
+          [[ "$clang_path" == *".llvm"* ]]
+          # Check that creduce is installed
+          creduce --version
+
+      # For debugging the setup locally, you can uncomment this step and run
+      # `act -P ubuntu-22.04=catthehacker/ubuntu:full-22.04 -W ./.github/workflows/copilot-setup-steps.yml`
+      # - name: Setup upterm session
+      #   uses: owenthereal/action-upterm@v1
+      #   with:
+      #     limit-access-to-users: zebreus
diff --git a/.github/workflows/documentation.yaml b/.github/workflows/documentation.yaml
index 7a023a4f5c..3dabcd24e2 100644
--- a/.github/workflows/documentation.yaml
+++ b/.github/workflows/documentation.yaml
@@ -3,34 +3,33 @@ name: Documentation
 on:
   push:
     branches:
-      - 'main'
+      - "main"
     paths:
-      - 'lib/**'
-
-env:
-  MSRV: "1.74"
+      - "lib/**"
 
 jobs:
   documentation:
     name: Documentation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
       - name: Install LLVM
         shell: bash
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf ${{ env.LLVM_URL }} -L -o llvm.tar.xz
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf ${{ env.LLVM_URL }} -L -o llvm.tar.xz
           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_211_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-21
+          LLVM_URL: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.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..b9eb5b9b9c 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,10 +24,10 @@ 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"
   NEXTEST_PROFILE: "ci"
   RUSTUP_WINDOWS_PATH_ADD_BIN: 1
   WASI_SDK_VERSION: "22"
+  S3_CACHE_VERSION: "3"
 
 jobs:
   setup:
@@ -52,30 +52,34 @@ jobs:
     name: Code lint
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
           components: rustfmt, clippy
+          targets: wasm32-unknown-unknown
       - name: Install libtinfo
         shell: bash
         run: |
           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 -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-amd64.tar.xz -L -o /opt/llvm.tar.xz
+          mkdir -p /opt/llvm-21
+          tar xf /opt/llvm.tar.xz --strip-components=1 -C /opt/llvm-21
+          echo '/opt/llvm-21/bin' >> $GITHUB_PATH
+          echo 'LLVM_SYS_211_PREFIX=/opt/llvm-21' >> $GITHUB_ENV
       - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
         uses: whywaita/actions-cache-s3@v2
         with:
           path: |
             ~/.cargo/*
             ./target/*
-          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-lint-linux-x64
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-lint-linux-x64
           aws-s3-bucket: wasmer-rust-artifacts-cache
           aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
           aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
@@ -88,6 +92,7 @@ jobs:
           ENABLE_CRANELIFT: "1"
           ENABLE_LLVM: "1"
           ENABLE_SINGLEPASS: "1"
+      - run: make lint-js
       - name: Assert no files have changed
         run: |
           git status
@@ -97,44 +102,88 @@ jobs:
     name: cargo-deny
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: actions/checkout@v6
+      - uses: EmbarkStudios/cargo-deny-action@v2
         with:
           log-level: error
 
   test_nodejs:
-    name: Test on NodeJS
+    name: NodeJS
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
       - 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
+      - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-js
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
       - name: make test-js
         run: |
           make test-js
 
   test_wasi_fyi:
-    name: Test wasi-fyi
+    name: Wasi-fyi
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - 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 21
+        run: |
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/21.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_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+      - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-wasi-fyi
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
       - name: make test-wasi-fyi
         run: |
           make test-wasi-fyi
@@ -145,163 +194,261 @@ jobs:
       #     make test-js-core
 
   test_wasix:
-    name: Test WASIX
+    name: WASIX
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
       - name: Install Tools
         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: Install wasixcc
+        uses: wasix-org/wasixcc@main
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          sysroot-tag: v2025-12-22.1
+
+      - name: Tool versions
+        run: |
+          echo "wasixcc version: $(wasixcc --version)"
+          echo "llvm version: $(wasixcc -- --version)"
+          echo "wasm-opt version: $(wasm-opt --version)"
+      - name: Install LLVM 21 (for building Wasmer)
+        run: |
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/21.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_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+      - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-wasix
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
       - name: make test-wasix
         run: |
-          WASI_SDK=~/wasi-sdk WASIX_SYSROOT=~/wasix-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
-      - name: make build-wasmer-wasm
-        run: make build-wasmer-wasm
+          WASI_SDK=~/wasi-sdk WASIX_SYSROOT=$(pwd)/sysroot/wasix-sysroot/sysroot make test-wasix
 
   test_build_jsc:
-    name: Test JSC build
+    name: JSC
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
           target: x86_64-unknown-linux-gnu
+          components: clippy
       - name: Install NodeJS
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: 16
       - name: Install libjavascriptcoregtk-4.0-dev
         run: sudo apt update && sudo apt install -y libjavascriptcoregtk-4.0-dev
+      - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-build-wasmer-jsc
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
+      - name: lint jsc
+        run: make lint-jsc
       - name: make build-wasmer-jsc
         run: make build-wasmer-jsc
 
+  test_interpreter_api:
+    name: ${{ matrix.build-what.name }} - ${{ matrix.metadata.build }}
+    runs-on: ${{ matrix.metadata.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        build-what:
+          [
+            {
+              key: wamr,
+              lint-cmd: "make lint-wamr",
+              build-cmd: "make test-wamr-api",
+              name: "API (wamr)",
+            },
+            {
+              key: wasmi,
+              lint-cmd: "make lint-wasmi",
+              build-cmd: "make test-wasmi-api",
+              name: "API (wasmi)",
+            },
+            {
+              key: v8,
+              lint-cmd: "make lint-v8",
+              build-cmd: "make test-v8-api",
+              name: "API (v8)",
+            },
+          ]
+        metadata: [
+            { build: linux-x64, os: ubuntu-22.04 },
+            { build: macos-arm, os: depot-macos-14 },
+            #{
+            #  build: windows-x64,
+            #  os: windows-2022,
+            #}
+          ]
+    container: ${{ matrix.metadata.container }}
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup MSVC (Windows)
+        uses: ilammy/msvc-dev-cmd@v1
+        if: matrix.metadata.build == 'windows-x64'
+
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
+          components: clippy
+
+      - 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@21
+          echo "/opt/homebrew/opt/llvm@21/bin" >> $GITHUB_PATH
+          ls -laR /opt/homebrew/opt/llvm@21/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: Lint ${{ matrix.build-what.key }}
+        run: ${{ matrix.build-what.lint-cmd }}
+
+      - 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
+    name: Build docs.rs
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "nightly-2023-10-05"
+          toolchain: "nightly-2025-09-27"
           target: x86_64-unknown-linux-gnu
-      - run: cargo install toml-cli # toml-cli is required to run `make test-build-docs-rs`
-      - name: make test-build-docs-rs-ci
-        run: make test-build-docs-rs-ci
+      - run: cargo install toml-cli --locked # toml-cli is required to run `make test-build-docs-rs`
 
-  build_linux_aarch64:
-    name: ${{ matrix.build-what.name }} on linux-aarch64
-    runs-on: ubuntu-22.04
-    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'
-          }
-        ]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.MSRV }}
-          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 ${{ matrix.build-what.key }}
+      - name: Install `ninja` on Ubuntu
+        shell: bash
         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_TARGET: aarch64-unknown-linux-gnu
-          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' }}
+          sudo apt-get install ninja-build -y
+
+      - name: Install LLVM 21
         run: |
-          make distribution
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/21.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_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         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
-        if: ${{ matrix.build-what.key == 'capi' }}
-        uses: actions/upload-artifact@v3
-        with:
-          name: capi-linux-aarch64
-          path: dist
-          if-no-files-found: error
-          retention-days: 2
+          LLVM_DIR: .llvm
+      - name: make test-build-docs-rs-ci
+        run: make test-build-docs-rs-ci
 
   build_linux_riscv64:
-    name: ${{ matrix.build-what.name }} on linux-riscv64
+    name: ${{ matrix.build-what.name }} - linux-riscv64
     runs-on: ubuntu-22.04
     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: wast-tests,
+              build-cmd: "make test-stage-0-wast",
+              name: "WAST tests",
+            },
+            {
+              key: capi,
+              build-cmd: "make build-capi && make package-capi",
+              name: "C-API",
+            },
+            {
+              key: wasmer,
+              build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
+              name: "Wasmer-cli binary",
+            },
+          ]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      #- uses: ./.github/actions/load_toolchain
+      #  id: load_toolchain
       #- uses: dtolnay/rust-toolchain@stable
       #  with:
-      #    toolchain: ${{ env.MSRV }}
+      #    toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
       #    target: riscv64gc-unknown-linux-gnu
       - name: Build cross image
         run: |
@@ -330,7 +477,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
@@ -338,66 +485,104 @@ jobs:
           retention-days: 2
 
   build:
-    name: ${{ matrix.build-what.name }} on ${{ matrix.metadata.build }}
+    name: ${{ matrix.build-what.name }} - ${{ matrix.metadata.build }}
     runs-on: ${{ matrix.metadata.os }}
     needs: setup
     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: "C-API",
+            },
+            {
+              key: capi-v8,
+              build-cmd: "make test-capi-v8",
+              name: "C-API with v8",
+            },
+            {
+              key: wasmer,
+              build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
+              name: "Wasmer-cli binary",
+            },
+            {
+              key: "check",
+              build-cmd: "make check",
+              name: "Wasmer API (sys)",
+            },
+            {
+              key: "api-feats",
+              build-cmd: "make check-api-features",
+              name: "API (sys)",
+            },
+          ]
         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/21.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: linux-arm64,
+              os: ubuntu-22.04-arm,
+              target: aarch64-unknown-linux-gnu,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-aarch64.tar.xz",
+              supports_v8: false,
+            },
+            {
+              build: macos-x64,
+              os: macos-15-intel,
+              target: x86_64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-amd64.tar.xz",
+              supports_v8: true,
+            },
+            {
+              build: macos-arm,
+              os: depot-macos-14,
+              target: aarch64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-aarch64.tar.xz",
+              supports_v8: true,
+            },
+            {
+              build: windows-x64,
+              os: windows-2022,
+              target: x86_64-pc-windows-msvc,
+              exe: ".exe",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.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:edge",
+              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@v6
+      - name: Set up Depot CLI
+        uses: depot/setup-action@v1
       - name: Set up libstdc++ on Linux
         if: matrix.metadata.build == 'linux-x64'
         run: |
@@ -406,21 +591,32 @@ 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
       - 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-15-intel'
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
           target: ${{ matrix.metadata.target }}
+          components: rustfmt,clippy
       - 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,35 +638,42 @@ 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 ""
           mkdir -p package
           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
+      - name: Install LLVM (macOS Intel)
+        if: matrix.metadata.os == 'macos-15-intel' && !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
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --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 "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_211_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: |
@@ -480,23 +683,14 @@ jobs:
           target = "${{ matrix.metadata.target }}"
           EOF
         if: matrix.metadata.target
-      - name: which cargo
-        if: ${{ matrix.build-what.key == 'capi' && matrix.metadata.build == 'windows-x64' }}
-        run: which cargo
-      - name: Set cargo env
-        run: echo "CARGO_ROOT_DIR=$(dirname $(dirname $( which cargo )))" >> $GITHUB_ENV
-      - name: List root dir
-        shell: bash
-        if: ${{ matrix.build-what.key == 'capi' && matrix.metadata.build == 'windows-x64' }}
-        run: ls -R $CARGO_ROOT_DIR
       - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
         uses: whywaita/actions-cache-s3@v2
         with:
           path: |
             ~/.cargo/*
             ./target/*
-            $CARGO_ROOT_DIR/*
-          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-build-wasmer-${{ matrix.build-what.key }}-${{ matrix.metadata.build }}
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-build-wasmer-${{ matrix.build-what.key }}-${{ matrix.metadata.build }}
           aws-s3-bucket: wasmer-rust-artifacts-cache
           aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
           aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
@@ -507,45 +701,64 @@ jobs:
       - name: Build C-API
         shell: bash
         run: ${{ matrix.build-what.build-cmd }}
-        if: ${{ matrix.build-what.key == 'capi' }}
+        if: ${{ matrix.build-what.key == 'capi' && matrix.metadata.build != 'macos-x64' }}
         env:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: 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' }}
+        if: ${{ matrix.build-what.key == 'wasmer' && matrix.metadata.build != 'windows-gnu' && matrix.metadata.build != 'macos-x64' }}
         run: ${{ matrix.build-what.build-cmd }}
         env:
           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' && matrix.metadata.build != 'macos-x64' }}
+        run: ${{ matrix.build-what.build-cmd }}
+
+      - name: Lint C-API
+        shell: bash
+        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl'  || matrix.metadata.build == 'windows-gnu' || matrix.metadata.build == 'macos-x64') }}
+        run: make lint-capi-ci
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+
       - 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' || matrix.metadata.build == 'macos-x64') }}
         run: make test-capi-ci
         env:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
+
       # 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' || matrix.metadata.build == 'macos-x64') }}
         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
@@ -553,81 +766,109 @@ jobs:
           retention-days: 2
 
   test:
-    name: ${{ matrix.stage.description }} on ${{ matrix.metadata.build }}
+    name: ${{ matrix.stage.description }} - ${{ matrix.metadata.build }}
     runs-on: ${{ matrix.metadata.os }}
     needs: setup
     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: "WAST (all comp.)",
+              make: "test-stage-0-wast",
+            },
+            {
+              description: "Packages - std",
+              make: "test-stage-1-test-all",
+            },
+            {
+              description: "Cranelift - no-std",
+              make: "test-stage-2-test-compiler-cranelift-nostd",
+            },
+            {
+              description: "Singlepass - no-std",
+              make: "test-stage-3-test-compiler-singlepass-nostd",
+            },
+            {
+              description: "Wasmer-cli",
+              make: "test-stage-4-wasmer-cli",
+            },
+            {
+              description: "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'
-          }
-        ]
-    container: ${{ matrix.metadata.container }}
-    env:
-      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
-      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+            {
+              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/21.x/llvm-linux-amd64.tar.xz",
+            },
+            {
+              build: linux-arm64,
+              os: ubuntu-22.04-arm,
+              target: aarch64-unknown-linux-gnu,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-aarch64.tar.xz",
+            },
+            {
+              build: macos-x64,
+              os: macos-15-intel,
+              target: x86_64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-amd64.tar.xz",
+            },
+            {
+              build: macos-arm,
+              os: depot-macos-14,
+              target: aarch64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-aarch64.tar.xz",
+            },
+            {
+              build: windows-x64,
+              os: windows-2022,
+              target: x86_64-pc-windows-msvc,
+              exe: ".exe",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-windows-amd64.tar.xz"
+            },
+            {
+              build: linux-musl,
+              target: x86_64-unknown-linux-musl,
+              os: ubuntu-22.04,
+              exe: "",
+              container: "alpine:edge",
+            },
+          ]
+    container:
+      image: ${{ matrix.metadata.container }}
+      volumes:
+        - /usr/local:/host/usr/local
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - name: Show disk capacity
+        if: startsWith(matrix.metadata.build, 'linux')
+        run: df -h
+      # Saves ~21 GiB
+      - name: Clean up disk space (container)
+        run: |
+          rm -rf /__t/*
+          rm -rf /host/usr/local/.ghcup
+          rm -rf /host/usr/local/lib/android
+        if: startsWith(matrix.metadata.build, 'linux') && matrix.metadata.container != ''
+      # Saves ~16 GiB
+      - name: Clean up disk space (native)
+        run: |
+          sudo rm -rf /__t/*
+          sudo rm -rf /usr/local/.ghcup
+          sudo rm -rf /usr/local/lib/android
+        if: startsWith(matrix.metadata.build, 'linux') && matrix.metadata.container == ''
+      - name: Show disk capacity
+        if: startsWith(matrix.metadata.build, 'linux')
+        run: df -h
       - name: Set up libstdc++ on Linux
         if: matrix.metadata.build == 'linux-x64'
         run: |
@@ -636,37 +877,65 @@ 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
+      - 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-15-intel'
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
           target: ${{ matrix.metadata.target }}
       - 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
+      - name: Install LLVM (macOS Intel)
+        if: matrix.metadata.os == 'macos-15-intel' && !matrix.metadata.llvm_url
         run: |
           brew install llvm
+          echo "/opt/homebrew/opt/llvm/bin" >> GITHUB_PATH
+
+      - name: Install wasixcc
+        if: matrix.metadata.build != 'windows-x64'
+        uses: wasix-org/wasixcc@main
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          sysroot-tag: v2025-12-22.1
+
       - 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
+          curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" --retry 3 --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_211_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' || matrix.metadata.os == 'depot-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: |
@@ -677,12 +946,13 @@ jobs:
           EOF
         if: matrix.metadata.target
       - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
         uses: whywaita/actions-cache-s3@v2
         with:
           path: |
             ~/.cargo/*
             ./target/*
-          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-stage-${{ matrix.stage.make }}-${{ matrix.metadata.build }}
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-stage-${{ matrix.stage.make }}-${{ matrix.metadata.build }}
           aws-s3-bucket: wasmer-rust-artifacts-cache
           aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
           aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
@@ -691,16 +961,19 @@ jobs:
           aws-s3-bucket-endpoint: false
           aws-s3-force-path-style: true
       - name: ${{ matrix.stage.description }}
+        shell: bash
         run: make ${{ matrix.stage.make }}
+        # For MacOS x64 - run tests only on main or release branches
+        if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-') || matrix.metadata.os != 'macos-15-intel'
         env:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
 
   test_integration_cli:
-    name: CLI integration tests on ${{ matrix.build }}
+    name: CLI tests - ${{ matrix.build }}
     runs-on: ${{ matrix.os }}
-    needs: [build, build_linux_aarch64, build_linux_riscv64]
+    needs: [build, build_linux_riscv64]
     strategy:
       fail-fast: false
       matrix:
@@ -708,57 +981,60 @@ 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'
-          - 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'
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-amd64.tar.xz"
+            exe: ""
           # we only build the integration-test CLI, we don't run tests
           - build: macos-arm
-            os: macos-12
+            os: depot-macos-14
             target: aarch64-apple-darwin,
+            exe: ""
           - build: linux-musl
             target: x86_64-unknown-linux-musl
             os: ubuntu-22.04
-            container: alpine:latest
+            container: alpine:edge
+            exe: ""
           - build: windows-x64
-            os: windows-2019
+            os: windows-latest
             target: x86_64-pc-windows-msvc
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-windows-amd64.tar.xz"
+            exe: ".exe"
+
     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@v6
       - 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
+      - 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}}
+      - uses: ./.github/actions/load_toolchain
+        id: load_toolchain
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: ${{ env.MSRV }}
-          target: ${{ matrix.metadata.target }}
+          toolchain: ${{ steps.load_toolchain.outputs.rust_toolchain }}
+          target: ${{ matrix.target }}
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
       - name: Cache
+        # TODO: v3 is unable to Restore the cache for some reason
         uses: whywaita/actions-cache-s3@v2
         with:
           path: |
             ~/.cargo/*
             ./target/*
-          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-integration-cli-${{ matrix.build }}
+          key: cache-v${{ env.S3_CACHE_VERSION }}-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-integration-cli-${{ matrix.build }}
           aws-s3-bucket: wasmer-rust-artifacts-cache
           aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
           aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
@@ -771,30 +1047,26 @@ jobs:
         run: |
           mkdir -p package
           mkdir -p package/cache
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: capi-linux-aarch64
+          name: capi-linux-arm64
           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
-        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
+          path: package/cache/wasmercache4
+      - uses: actions/download-artifact@v4
         with:
           name: capi-linux-riscv64
-          path: package/cache/wasmercache6
+          path: package/cache/wasmercache5
       - name: Copy .tar.gz files to proper location
         shell: bash
         run: |
@@ -803,33 +1075,27 @@ jobs:
           ls package/cache/wasmercache3
           ls package/cache/wasmercache4
           ls package/cache/wasmercache5
-          cp package/cache/wasmercache1/wasmer.tar.gz package/cache/wasmer-linux-aarch64.tar.gz
+          cp package/cache/wasmercache1/build-capi.tar.gz package/cache/wasmer-linux-arm64.tar.gz
           cp package/cache/wasmercache2/build-capi.tar.gz package/cache/wasmer-windows-gnu64.tar.gz
           cp package/cache/wasmercache3/build-capi.tar.gz package/cache/wasmer-darwin-arm64.tar.gz
           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
+          cp package/cache/wasmercache5/wasmer.tar.gz package/cache/wasmer-linux-riscv64.tar.gz
+      - 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
-        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 +1112,60 @@ 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:
+    name: "Remote integ. 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"
+      registry: wasmer.io
+    secrets:
+      token: ${{ secrets.PROD_BACKEND_CIUSER_TOKEN }}
diff --git a/.github/workflows/wasmer-config.yaml b/.github/workflows/wasmer-config.yaml
index 9091574b1e..5e4856d2b9 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@v6
       - 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@v6
       - 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..5d0338d0d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@
 .DS_Store
 .idea
 .gdb_history
-/.cargo/
 **/.vscode/*
 !/.vscode/settings.json
 api-docs-repo/
@@ -29,3 +28,7 @@ lcov.info
 link/
 link.tar.gz
 .vscode
+# Ignore files used by the "direnv" tool.
+.direnv
+.envrc
+/tests/tmp
diff --git a/lib/wasix/src/state/pipe.rs b/.gitmodules
similarity index 100%
rename from lib/wasix/src/state/pipe.rs
rename to .gitmodules
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae9d57a866..94e48f018d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,10 +4,866 @@
 
 [Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
 
-Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/CHANGELOG.md).
+## **Unreleased**
+
+## 7.0.0 - 28/01/2026
+
+This release adds:
+- New WASIX Context switching API (green threads).
+- New (experimental) Async API (enable it using the `experimental-async` feature in wasmer)
+- Full support for Dynamic Linking in WASIX.
+- Wasmer compilation progress bar.
+- Improved debugging experience via `--compiler-debug-dir`.
+- Singlepass: RISC-V (64-bit) support.
+- Singlepass: Multi-value support.
+- Cranelift: Exception handling support.
+- LLVM: Updated backend from LLVM 18 → LLVM 21.
+- LLVM: New target support for RISC-V (32-bit).
+- LLVM: Disabled optimizations for huge functions (e.g. Python compile time ~90s → ~10s).
+- Many secondary platform fixes and improvements for `aarch64-linux`, `riscv64gc-linux`, and `loongarch64-linux`.
+- Many bugfixes and improvements.
+
+## Added
+
+
+## Changed
+
+  - [#6125](https://github.com/wasmerio/wasmer/pull/6125) build(v8): disable in the official tarballs
+
+## Fixed
+
+  - [#6127](https://github.com/wasmerio/wasmer/pull/6127) fix(virtual-fs): Fix read_dir missing mount prefix
+  - [#6130](https://github.com/wasmerio/wasmer/pull/6130) Fix copilot setup
+
+
+
+## 7.0.0-rc.2 - 27/01/2026
+
+## Added
+
+  - [#6066](https://github.com/wasmerio/wasmer/pull/6066) Add a better setup for copilot
+
+## Changed
+
+  - [#6119](https://github.com/wasmerio/wasmer/pull/6119) feat(LLVM): use verbose asm output for debug output
+  - [#6120](https://github.com/wasmerio/wasmer/pull/6120) chore(fuzzing): tweak options and save file early
+  - [#6107](https://github.com/wasmerio/wasmer/pull/6107) Remove hardcoded MSRV in github actions
+  - [#6115](https://github.com/wasmerio/wasmer/pull/6115) chore(fuzzing): small refactor
+  - [#6096](https://github.com/wasmerio/wasmer/pull/6096) build: Switch back to plain rust-toolchain file
+
+## Fixed
+
+  - [#6118](https://github.com/wasmerio/wasmer/pull/6118) fix(LLVM): fix ABI related to pointer type
+  - [#6123](https://github.com/wasmerio/wasmer/pull/6123) fix: do not use engine.new_module_with_progress for non-sys Engines
+  - [#6117](https://github.com/wasmerio/wasmer/pull/6117) fix(LLVM): record try_table in unreachable_depth
+  - [#6114](https://github.com/wasmerio/wasmer/pull/6114) fix(LLVM): fixed ABI issues noticed while fuzzing
+  - [#6109](https://github.com/wasmerio/wasmer/pull/6109) fix(cranelift): support ::Exn (fix php/php-32 compilation)
+  - [#6108](https://github.com/wasmerio/wasmer/pull/6108) fix(docs.rs): fix documentation build (RC version of `sha2` crate)
+  - [#6112](https://github.com/wasmerio/wasmer/pull/6112) fix(wasix): Restore proper webc v2 mount handling
+
+
+
+## 7.0.0-rc.1 - 23/01/2026
+
+## Added
+
+  - [#6051](https://github.com/wasmerio/wasmer/pull/6051) Add Rust tools to Nix development environment
+  - [#6054](https://github.com/wasmerio/wasmer/pull/6054) tests: add EH-related test
+  - [#5711](https://github.com/wasmerio/wasmer/pull/5711) SinglePass: add support for riscv64 target
+  - [#6020](https://github.com/wasmerio/wasmer/pull/6020) fix(loongarch64,riscv64gc,aarch64): add missing relocations and fix EH
+  - [#5984](https://github.com/wasmerio/wasmer/pull/5984) CI: add Cache step for more runs
+  - [#5967](https://github.com/wasmerio/wasmer/pull/5967) cli: add short options for the compilers
+  - [#5963](https://github.com/wasmerio/wasmer/pull/5963) CI: run WASIX tests on Cranelift and exception test added
+  - [#5965](https://github.com/wasmerio/wasmer/pull/5965) Add -q flag to WASMER_RUN in WASIX test suite
+  - [#5848](https://github.com/wasmerio/wasmer/pull/5848) feature(singlepass): add --debug-dir for assembly output
+  - [#5894](https://github.com/wasmerio/wasmer/pull/5894) Documentation to add second R integration WIP package
+  - [#5916](https://github.com/wasmerio/wasmer/pull/5916) CI: add posix-compatible TAR for alpine
+  - [#5910](https://github.com/wasmerio/wasmer/pull/5910) Add Wasmer LinkedIn link to README
+  - [#5869](https://github.com/wasmerio/wasmer/pull/5869) Singlepass: add multivalue support
+
+## Changed
+
+  - [#6099](https://github.com/wasmerio/wasmer/pull/6099) chore(test-wasix): use --volume instead of --dir argument
+  - [#6069](https://github.com/wasmerio/wasmer/pull/6069) Support compressed package downloads
+  - [#6048](https://github.com/wasmerio/wasmer/pull/6048) deps: bump MSRV to 1.91
+  - [#6093](https://github.com/wasmerio/wasmer/pull/6093) CI: skip tests on RISC-V and LoongArch64
+  - [#6096](https://github.com/wasmerio/wasmer/pull/6096) build: Switch back to plain rust-toolchain file
+  - [#6042](https://github.com/wasmerio/wasmer/pull/6042) feat: include module hash in `--compiler-debug-dir` path
+  - [#6065](https://github.com/wasmerio/wasmer/pull/6065) CI(docs.rs): not use --no-deps as a workaround
+  - [#6090](https://github.com/wasmerio/wasmer/pull/6090) deps: bump Cranelift to 0.128.0
+  - [#6082](https://github.com/wasmerio/wasmer/pull/6082) deps: bump zip crate
+  - [#6080](https://github.com/wasmerio/wasmer/pull/6080) chore: drop `xxhash` hashing algorithm
+  - [#6063](https://github.com/wasmerio/wasmer/pull/6063) feature(cli): Use a new R2 upload mechanism for publishing packages
+  - [#6035](https://github.com/wasmerio/wasmer/pull/6035) deps: bump criterion crate
+  - [#6033](https://github.com/wasmerio/wasmer/pull/6033) feat: replace `--mapdir` and `--map` with `--volume` argument
+  - [#6088](https://github.com/wasmerio/wasmer/pull/6088) chore: get rid of static mut variables
+  - [#6085](https://github.com/wasmerio/wasmer/pull/6085) chore: delete empty files
+  - [#6036](https://github.com/wasmerio/wasmer/pull/6036) chore: use hex crate instead of custom format
+  - [#6081](https://github.com/wasmerio/wasmer/pull/6081) deps: bump cranelift version
+  - [#6034](https://github.com/wasmerio/wasmer/pull/6034) deps: bump tungstenite-related crates
+  - [#6050](https://github.com/wasmerio/wasmer/pull/6050) tools: port make-release.py to format after Ruff + include RELEASE.md
+  - [#6029](https://github.com/wasmerio/wasmer/pull/6029) tests: list known failing tests
+  - [#6030](https://github.com/wasmerio/wasmer/pull/6030) CI: run some tests for all compilers
+  - [#6071](https://github.com/wasmerio/wasmer/pull/6071) chore: drop .cargo/config.toml
+  - [#5883](https://github.com/wasmerio/wasmer/pull/5883) Progress reporting for module loading and compilation
+  - [#6056](https://github.com/wasmerio/wasmer/pull/6056) CI: do not run test as part of binary build
+  - [#6068](https://github.com/wasmerio/wasmer/pull/6068) CI: restore cache + free some disk space
+  - [#6047](https://github.com/wasmerio/wasmer/pull/6047) chore: code clean-up
+  - [#6053](https://github.com/wasmerio/wasmer/pull/6053) chore(singlepass): drop `riscv` feature
+  - [#6049](https://github.com/wasmerio/wasmer/pull/6049) Release 7.0.0-alpha.2
+  - [#6043](https://github.com/wasmerio/wasmer/pull/6043) feat: `--compiler-threads` supported by all compilers
+  - [#6044](https://github.com/wasmerio/wasmer/pull/6044) Release 7.0.0-alpha.1
+  - [#6041](https://github.com/wasmerio/wasmer/pull/6041) CI: disable v8 for linux-arm64 target
+  - [#6018](https://github.com/wasmerio/wasmer/pull/6018) CI(aarch64-linux): include into testing matrix
+  - [#6027](https://github.com/wasmerio/wasmer/pull/6027) deps: bump used crates
+  - [#6023](https://github.com/wasmerio/wasmer/pull/6023) chore: always use Rayon thread pool (even for one thread)
+  - [#6025](https://github.com/wasmerio/wasmer/pull/6025) deps(inkwell): bump to 0.8.0
+  - [#5475](https://github.com/wasmerio/wasmer/pull/5475) Disallow mounting folders on the guest's root for WASIX modules
+  - [#6021](https://github.com/wasmerio/wasmer/pull/6021) deps: allow bincode in cargo-deny (RUSTSEC-2025-0141)
+  - [#6016](https://github.com/wasmerio/wasmer/pull/6016) Remove ucontext_t definition for FreeBSD for aarch64
+  - [#5994](https://github.com/wasmerio/wasmer/pull/5994) deps: bump wasm-smith and enable fuzzers
+  - [#5997](https://github.com/wasmerio/wasmer/pull/5997) feat(LLVM): use no-opt for extremely large functions
+  - [#5980](https://github.com/wasmerio/wasmer/pull/5980) setjmp/longjmp based vforking
+  - [#6001](https://github.com/wasmerio/wasmer/pull/6001) deps: bump cranelift to 0.127.0
+  - [#5996](https://github.com/wasmerio/wasmer/pull/5996) deps: bump crates
+  - [#5987](https://github.com/wasmerio/wasmer/pull/5987) chore: cleanup
+  - [#5989](https://github.com/wasmerio/wasmer/pull/5989) deps: bump `wasmparser` crate and port to it
+  - [#5986](https://github.com/wasmerio/wasmer/pull/5986) CI: include Bearer + retry for getting LLVM tarball release
+  - [#5985](https://github.com/wasmerio/wasmer/pull/5985) chore: don't call Features::detect_from_wasm if enable all option is on
+  - [#5983](https://github.com/wasmerio/wasmer/pull/5983) chore: simplify rounding up (align up) logic - use std library
+  - [#5973](https://github.com/wasmerio/wasmer/pull/5973) chore: drop dead code available with `--compiler-debug-dir`
+  - [#5978](https://github.com/wasmerio/wasmer/pull/5978) Make all WASIX interop enums non_exhaustive to prevent UB in case of …
+  - [#5979](https://github.com/wasmerio/wasmer/pull/5979) Prevent failure due to rate limits when installing `wasixcc`
+  - [#5975](https://github.com/wasmerio/wasmer/pull/5975) chore: drop non top-level Cargo.lock files
+  - [#5881](https://github.com/wasmerio/wasmer/pull/5881) Implement WASIX context switching API
+  - [#5972](https://github.com/wasmerio/wasmer/pull/5972) feat: drop mounting of a journal feature (fuse feature)
+  - [#5720](https://github.com/wasmerio/wasmer/pull/5720) Give variables in find_eh_action more descriptive names
+  - [#5968](https://github.com/wasmerio/wasmer/pull/5968) chore: resolve build warnings with all features enabled
+  - [#5969](https://github.com/wasmerio/wasmer/pull/5969) deps: bump wasm-coredump-builder crate
+  - [#5970](https://github.com/wasmerio/wasmer/pull/5970) deps: bump bincode to 2.0
+  - [#5964](https://github.com/wasmerio/wasmer/pull/5964) chore: use EH-related `Gimli` crate constants
+  - [#5966](https://github.com/wasmerio/wasmer/pull/5966) deps: bump wasmi crate
+  - [#5962](https://github.com/wasmerio/wasmer/pull/5962) Support EH for Cranelift compiler
+  - [#5957](https://github.com/wasmerio/wasmer/pull/5957) feature: disable crate-exe and create-obj subcommands
+  - [#5913](https://github.com/wasmerio/wasmer/pull/5913) CI: drop unused sccache and handle GH workflow issues
+  - [#5944](https://github.com/wasmerio/wasmer/pull/5944) deps: sort crate depedencies alphabetically
+  - [#5959](https://github.com/wasmerio/wasmer/pull/5959) Pin wasix libc version in CI
+  - [#5938](https://github.com/wasmerio/wasmer/pull/5938) CI: shorten job names for UI purpose
+  - [#5956](https://github.com/wasmerio/wasmer/pull/5956) chore: simplify logic in UnwindRegistry
+  - [#5950](https://github.com/wasmerio/wasmer/pull/5950) Bump MSRV to 1.90
+  - [#5953](https://github.com/wasmerio/wasmer/pull/5953) Prevent crashes during exit due to deregistering frames on exit (v3)
+  - [#5926](https://github.com/wasmerio/wasmer/pull/5926) CI: run macos-15-intel only on main (not in PRs)
+  - [#5762](https://github.com/wasmerio/wasmer/pull/5762) Port to powerpc64 Linux
+  - [#5920](https://github.com/wasmerio/wasmer/pull/5920) Async execution API + concurrent execution support, take 2
+  - [#5925](https://github.com/wasmerio/wasmer/pull/5925) deps: bump crates (part 1)
+  - [#5917](https://github.com/wasmerio/wasmer/pull/5917) chore(singlepass): simplify arch_supports_x
+  - [#5940](https://github.com/wasmerio/wasmer/pull/5940) CI: disable multi-value (host fn) tests as it's borked on Windows for LLVM compiler
+  - [#5935](https://github.com/wasmerio/wasmer/pull/5935) CI: move Alpine to edge and use LLVM 21
+  - [#5936](https://github.com/wasmerio/wasmer/pull/5936) CI(LLVM): port mvr_test and enable them for LLVM compiler
+  - [#5937](https://github.com/wasmerio/wasmer/pull/5937) CI(LLVM): enable tests on Windows
+  - [#5892](https://github.com/wasmerio/wasmer/pull/5892) feat: Use macos (arm) 14 via depot runners
+  - [#5865](https://github.com/wasmerio/wasmer/pull/5865) build: move dependency declarations to top-level Cargo.toml
+  - [#5921](https://github.com/wasmerio/wasmer/pull/5921) CI: move back to working actions-cache-s3@v2
+  - [#5911](https://github.com/wasmerio/wasmer/pull/5911) build: use nightly for docs and port to it
+  - [#5919](https://github.com/wasmerio/wasmer/pull/5919) chore(singlepass): expect only register args in get_simple_param_location
+  - [#5914](https://github.com/wasmerio/wasmer/pull/5914) CI: leave MacOS 13 for x86_64 target.
+  - [#5909](https://github.com/wasmerio/wasmer/pull/5909) build(LLVM): drop unused code
+  - [#5900](https://github.com/wasmerio/wasmer/pull/5900) deps: bump Cranelift to 0.126.0
+  - [#5901](https://github.com/wasmerio/wasmer/pull/5901) Singlepass refactoring
+  - [#5897](https://github.com/wasmerio/wasmer/pull/5897) ci: bump actions-cache-s3
+  - [#5899](https://github.com/wasmerio/wasmer/pull/5899) CI: migrate workflows to checkout v6
+  - [#5896](https://github.com/wasmerio/wasmer/pull/5896) chore(cranelift): unify rayon and non-rayon code with closure
+  - [#5889](https://github.com/wasmerio/wasmer/pull/5889) build: switch to LLVM 21
+  - [#5885](https://github.com/wasmerio/wasmer/pull/5885) build: bump Inkwell crate
+  - [#5880](https://github.com/wasmerio/wasmer/pull/5880) deps: bump Cranelift to 0.125.4
+  - [#5874](https://github.com/wasmerio/wasmer/pull/5874) chore: bump MSRV to 1.89 and update the docs accordingly
+  - [#5871](https://github.com/wasmerio/wasmer/pull/5871) ci(windows): align unsafe functions for Windows target
+  - [#5861](https://github.com/wasmerio/wasmer/pull/5861) feature: rework `--debug-dir` option
+  - [#5862](https://github.com/wasmerio/wasmer/pull/5862) drop cli-compiler crate
+  - [#5867](https://github.com/wasmerio/wasmer/pull/5867) chore: use git_version crate for hash embedding in CLI
+  - [#5863](https://github.com/wasmerio/wasmer/pull/5863) CI: run test-stage-1-test-all in parallel
+  - [#5856](https://github.com/wasmerio/wasmer/pull/5856) feat(cli): Extend '--version --verbose' with CPU info
+  - [#5850](https://github.com/wasmerio/wasmer/pull/5850) chore(LLVM): use write_all
+  - [#5851](https://github.com/wasmerio/wasmer/pull/5851) chore(singlepass): unify acquire/release-location related functions
+  - [#5852](https://github.com/wasmerio/wasmer/pull/5852) Linker: stop giving main modules a memory_base of zero + stop assumin…
+  - [#5825](https://github.com/wasmerio/wasmer/pull/5825) CLI: Code cleanup and small progressbar improvements
+  - [#5846](https://github.com/wasmerio/wasmer/pull/5846) refactor(singlepass): track FP canonicalization directly in value stack
+  - [#5842](https://github.com/wasmerio/wasmer/pull/5842) refactor(singlepass): drop MachineState
+  - [#5841](https://github.com/wasmerio/wasmer/pull/5841) refactor(singlepass): come up with `ControlState` struct
+  - [#5835](https://github.com/wasmerio/wasmer/pull/5835) refactor(singlepass): `acquire_locations` always takes just a single arg
+  - [#5834](https://github.com/wasmerio/wasmer/pull/5834) feature(ci): improve error message if no backend enabled
+  - [#5820](https://github.com/wasmerio/wasmer/pull/5820) ci: enable 2 issues tests to be run on all targets
+  - [#5814](https://github.com/wasmerio/wasmer/pull/5814) feat(virtual-fs): Export ops::walk
+  - [#5824](https://github.com/wasmerio/wasmer/pull/5824) refactor(singlepass): factor out registers used for calling a fn
+  - [#5812](https://github.com/wasmerio/wasmer/pull/5812) binfmt should use quiet mode + improvements to compilation progress reporting
+  - [#5755](https://github.com/wasmerio/wasmer/pull/5755) Rework EH some more to allow native access to exceptions
+  - [#5821](https://github.com/wasmerio/wasmer/pull/5821) Singlepass unreachable via fn call
+  - [#5822](https://github.com/wasmerio/wasmer/pull/5822) Singlepass refactor dead code
+  - [#5809](https://github.com/wasmerio/wasmer/pull/5809) ci: run test-stage-0-wast in parallel
+  - [#5817](https://github.com/wasmerio/wasmer/pull/5817) ci(cranelift): disable a crashing Cranelift test for riscv64gc target
+  - [#5818](https://github.com/wasmerio/wasmer/pull/5818) refactor: remove unused parts of FunctionStateMap
+  - [#5804](https://github.com/wasmerio/wasmer/pull/5804) refactor(singlepass): swap jmp_on_condition arguments
+  - [#5797](https://github.com/wasmerio/wasmer/pull/5797) Improve binfmt misc support
+  - [#5788](https://github.com/wasmerio/wasmer/pull/5788) Upgrade Cranelift to 0.124.2
+  - [#5794](https://github.com/wasmerio/wasmer/pull/5794) Upgrade to Rust 1.87 and 2024 Edition
+  - [#5792](https://github.com/wasmerio/wasmer/pull/5792) Make commands work when called from /usr/bin
+  - [#5749](https://github.com/wasmerio/wasmer/pull/5749) Singlepass: to_dwarf - use directly `gimli::Register` type
+  - [#5750](https://github.com/wasmerio/wasmer/pull/5750) Singlepass: refactor condition jumps to single fn (`jmp_on_condition`)
+
+## Fixed
+
+  - [#6102](https://github.com/wasmerio/wasmer/pull/6102) fix(macos-x64): restore unwind info
+  - [#6098](https://github.com/wasmerio/wasmer/pull/6098) fix(fuzz): fix also `deterministic` and `metering` targets
+  - [#6101](https://github.com/wasmerio/wasmer/pull/6101) fix: exception reference is i32 type
+  - [#6097](https://github.com/wasmerio/wasmer/pull/6097) fix(Windows): resolve `probestack` relocation target
+  - [#6094](https://github.com/wasmerio/wasmer/pull/6094) fix(fuzz): stabilization fixes + refactoring
+  - [#6074](https://github.com/wasmerio/wasmer/pull/6074) fix(wasix): handle empty subscription list in poll_oneoff
+  - [#6072](https://github.com/wasmerio/wasmer/pull/6072) fix(LLVM,riscv64): fix calling conventions for `i32` type
+  - [#6091](https://github.com/wasmerio/wasmer/pull/6091) fix: compact unwind info - use rangemap
+  - [#6087](https://github.com/wasmerio/wasmer/pull/6087) fix(LLVM,macOS): fix compact unwinding bookkeeping
+  - [#6086](https://github.com/wasmerio/wasmer/pull/6086) fix(cli): package download: do not rely on `Content-Length` header
+  - [#6007](https://github.com/wasmerio/wasmer/pull/6007) Enable riscv32 target in LLVM compiler & relocations fixes
+  - [#6079](https://github.com/wasmerio/wasmer/pull/6079) fix(LLVM): RISC-V rounding operations need an extra check
+  - [#6077](https://github.com/wasmerio/wasmer/pull/6077) fix(LLVM): fix extmul_high/extmul_low operations
+  - [#6046](https://github.com/wasmerio/wasmer/pull/6046) chore: fix publish issue
+  - [#6045](https://github.com/wasmerio/wasmer/pull/6045) fix(make-release): use full pull
+  - [#6040](https://github.com/wasmerio/wasmer/pull/6040) fix: downgrade zip crate and run generate-lockfile
+  - [#6008](https://github.com/wasmerio/wasmer/pull/6008) Fix/linker crash tls symbol without tls base
+  - [#6022](https://github.com/wasmerio/wasmer/pull/6022) fix: include endpoint URL in response cache location
+  - [#6026](https://github.com/wasmerio/wasmer/pull/6026) fix(_Unwind_RaiseException): ignore return value as it's unreliable
+  - [#5990](https://github.com/wasmerio/wasmer/pull/5990) fix: provide unique function names
+  - [#6019](https://github.com/wasmerio/wasmer/pull/6019) Fix typo in CompileError doc comment
+  - [#6014](https://github.com/wasmerio/wasmer/pull/6014) CI(cranelift): fix macos x64
+  - [#6015](https://github.com/wasmerio/wasmer/pull/6015) Fix trap handler for FreeBSD for aarch64
+  - [#6010](https://github.com/wasmerio/wasmer/pull/6010) fix(cranelift): EH: ensure CatchAll is always present at the end of an action linked list
+  - [#6012](https://github.com/wasmerio/wasmer/pull/6012) Fix relative_path_to_absolute
+  - [#5999](https://github.com/wasmerio/wasmer/pull/5999) fix(build): Update webkit in flake.nix
+  - [#6009](https://github.com/wasmerio/wasmer/pull/6009) fix(wasix): Fix wasip1 preopen handling for Go compatibility
+  - [#6013](https://github.com/wasmerio/wasmer/pull/6013) deps(rkyv): fix RUSTSEC-2026-0001
+  - [#5992](https://github.com/wasmerio/wasmer/pull/5992) fix: properly report size after memory.reset
+  - [#5995](https://github.com/wasmerio/wasmer/pull/5995) CI: fix and rename jobs on main
+  - [#5767](https://github.com/wasmerio/wasmer/pull/5767) fix(build): Meaningful compilation errors when no backend feature enabled
+  - [#5982](https://github.com/wasmerio/wasmer/pull/5982) fix: do not call `detect_features_from_wasm` with WAT content
+  - [#5981](https://github.com/wasmerio/wasmer/pull/5981) Fixed proc spawn2 when duplicating stdio fds
+  - [#5971](https://github.com/wasmerio/wasmer/pull/5971) CI: re-enable test due to fixed rustc +nightly
+  - [#5974](https://github.com/wasmerio/wasmer/pull/5974) fix: do not create folders for cache/queries entries
+  - [#5826](https://github.com/wasmerio/wasmer/pull/5826) chore(build): fix compilation warnings
+  - [#5960](https://github.com/wasmerio/wasmer/pull/5960) CI: fix failing CI jobs (failing FYI test, out of disk space with Cache)
+  - [#5945](https://github.com/wasmerio/wasmer/pull/5945) fix: Set LLVM target machine's ABI in a portable way
+  - [#5924](https://github.com/wasmerio/wasmer/pull/5924) fix(backend-api): Update GraphQL schema
+  - [#5799](https://github.com/wasmerio/wasmer/pull/5799) fix(wasix): Prevent recursive merge fallback when mounting packages
+  - [#5796](https://github.com/wasmerio/wasmer/pull/5796) fix(llvm): use llvm.minimum/maximum intrinsics and refactor NaN canonicalization
+  - [#5918](https://github.com/wasmerio/wasmer/pull/5918) fix(singlepass): properly align stack slots in deallocation
+  - [#5882](https://github.com/wasmerio/wasmer/pull/5882) fix(LLVM): fix compiler error on aarch64 target
+  - [#5902](https://github.com/wasmerio/wasmer/pull/5902) fix(cicd): Swap to new organizational ciuser token
+  - [#5888](https://github.com/wasmerio/wasmer/pull/5888) fix(cranelift): fix get_function_name reference lookup
+  - [#5890](https://github.com/wasmerio/wasmer/pull/5890) Fix clippy error and remove commented code
+  - [#5887](https://github.com/wasmerio/wasmer/pull/5887) CI(compiler): fix cargo deny issues connected to licenses
+  - [#5884](https://github.com/wasmerio/wasmer/pull/5884) fix(singlepass): fix wrong code connected to multivalue
+  - [#5878](https://github.com/wasmerio/wasmer/pull/5878) fix(compiler): limit the path component for debug files (to 255)
+  - [#5876](https://github.com/wasmerio/wasmer/pull/5876) fix(CI): do not mess up user's profile in default location
+  - [#5875](https://github.com/wasmerio/wasmer/pull/5875) fix(compiler): rename option to prevent option clash
+  - [#5873](https://github.com/wasmerio/wasmer/pull/5873) Fix compilation of virutal-net with the tokio feature enabled
+  - [#5866](https://github.com/wasmerio/wasmer/pull/5866) fix(cranelift): always use inline stack probes
+  - [#5854](https://github.com/wasmerio/wasmer/pull/5854) fix(CI): allow parallel run of all WASI tests
+  - [#5853](https://github.com/wasmerio/wasmer/pull/5853) fix(clippy): run cargo clippy for examples
+  - [#5844](https://github.com/wasmerio/wasmer/pull/5844) Linker: fix initialization order of main module
+  - [#5838](https://github.com/wasmerio/wasmer/pull/5838) Fix a number of WASIX stalls
+  - [#5843](https://github.com/wasmerio/wasmer/pull/5843) Bump MSRV to 1.88 (apply clippy fixes)
+  - [#5839](https://github.com/wasmerio/wasmer/pull/5839) App Templates fixes and improvements
+  - [#5840](https://github.com/wasmerio/wasmer/pull/5840) chore(clippy): fix remaining issues
+  - [#5827](https://github.com/wasmerio/wasmer/pull/5827) Clippy fixes
+  - [#5832](https://github.com/wasmerio/wasmer/pull/5832) fix(ci): disable empty workflow file
+  - [#5829](https://github.com/wasmerio/wasmer/pull/5829) fix(cli): show LLVM related options only if llvm compiler is enabled
+  - [#5808](https://github.com/wasmerio/wasmer/pull/5808) fix(llvm): fix compilation error with: CARGO_TARGET=riscv64gc-unknown…
+  - [#5815](https://github.com/wasmerio/wasmer/pull/5815) fix(tests): respect cargo --target argument correctly
+  - [#5802](https://github.com/wasmerio/wasmer/pull/5802) fix(singlepass): support 1K function call arguments
+  - [#5803](https://github.com/wasmerio/wasmer/pull/5803) fix(singlepass): Small Arm64 clean-up
+  - [#5806](https://github.com/wasmerio/wasmer/pull/5806) chore: fix some minor issues in the comments
+  - [#5793](https://github.com/wasmerio/wasmer/pull/5793) Fix wasm32 target compile warnings
+
+
+
+## 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
 
 
-## **Unreleased**
 
 ## 4.3.7 - 06/09/2024
 
@@ -1130,7 +1986,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..bd58f01b9d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,51 +1,27 @@
 # 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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
-dependencies = [
- "gimli 0.29.0",
-]
-
-[[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
-[[package]]
-name = "ahash"
-version = "0.7.8"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
- "getrandom",
- "once_cell",
- "version_check",
+ "gimli",
 ]
 
 [[package]]
-name = "ahash"
-version = "0.8.11"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
-dependencies = [
- "cfg-if 1.0.0",
- "getrandom",
- "once_cell",
- "version_check",
- "zerocopy",
-]
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
@@ -57,16 +33,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
 
 [[package]]
-name = "allocator-api2"
-version = "0.2.18"
+name = "alloca"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
 
 [[package]]
-name = "android-tzdata"
-version = "0.1.1"
+name = "allocator-api2"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "android_system_properties"
@@ -85,9 +64,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 +79,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.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
- "windows-sys 0.52.0",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -140,24 +120,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 +147,57 @@ checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "askama"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4744ed2eef2645831b441d8f5459689ade2ab27c854488fbab1fbe94fce1a7"
+dependencies = [
+ "askama_derive",
+ "itoa",
+ "percent-encoding",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "askama_derive"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d661e0f57be36a5c14c48f78d09011e67e0cb618f269cca9f2fd8d15b68c46ac"
+dependencies = [
+ "askama_parser",
+ "basic-toml",
+ "memchr",
+ "proc-macro2",
+ "quote",
+ "rustc-hash",
+ "serde",
+ "serde_derive",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "askama_parser"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "cf315ce6524c857bb129ff794935cf6d42c82a6cff60526fe2a63593de4d0d4f"
+dependencies = [
+ "memchr",
+ "serde",
+ "serde_derive",
+ "winnow",
+]
 
 [[package]]
-name = "ascii"
-version = "0.9.3"
+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,96 +215,144 @@ dependencies = [
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.14"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
+checksum = "9c5bcfa8749ac45dd12cb11055aeeb6b27a3895560d60d71e3c23bf979e60514"
 dependencies = [
  "anstyle",
- "bstr 1.9.1",
- "doc-comment",
- "predicates 3.1.0",
+ "bstr 1.12.1",
+ "libc",
+ "predicates 3.1.3",
  "predicates-core",
  "predicates-tree",
  "wait-timeout",
 ]
 
 [[package]]
-name = "async-compression"
-version = "0.4.12"
+name = "async-channel"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fec134f64e2bc57411226dfc4e52dec859ddfc7e711fc5e07b612584f000e4aa"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
- "flate2",
+ "concurrent-queue",
+ "event-listener-strategy",
  "futures-core",
- "memchr",
  "pin-project-lite",
- "tokio 1.38.1",
+]
+
+[[package]]
+name = "async-compression"
+version = "0.4.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d10e4f991a553474232bc0a31799f6d24b034a84c0971d80d2e2f78b2e576e40"
+dependencies = [
+ "compression-codecs",
+ "compression-core",
+ "pin-project-lite",
+ "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.114",
 ]
 
 [[package]]
 name = "async-tungstenite"
-version = "0.25.1"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cca750b12e02c389c1694d35c16539f88b8bbaa5945934fdc1b41a776688589"
+checksum = "8acc405d38be14342132609f06f02acaf825ddccfe76c4824a69281e0458ebd4"
 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",
+ "tokio",
+ "tokio-rustls",
  "tungstenite",
 ]
 
 [[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 = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "axum"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
 dependencies = [
- "critical-section",
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "sync_wrapper",
+ "tower",
+ "tower-layer",
+ "tower-service",
 ]
 
 [[package]]
-name = "autocfg"
-version = "1.3.0"
+name = "axum-core"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
 
 [[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"
@@ -295,6 +365,15 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "basic-toml"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "beef"
 version = "0.5.2"
@@ -311,40 +390,69 @@ dependencies = [
 ]
 
 [[package]]
-name = "bitflags"
-version = "1.3.2"
+name = "bincode"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
 
 [[package]]
-name = "bitflags"
-version = "2.6.0"
+name = "bincode_derive"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
 
 [[package]]
-name = "bitvec"
-version = "1.0.1"
+name = "bindgen"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
+ "bitflags 2.10.0",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.13.0",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.114",
 ]
 
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
 [[package]]
 name = "blake3"
-version = "1.5.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9ec96fe9a81b5e365f9db71fe00edc4fe4ca2cc7dcb7861f0603012a7caa210"
+checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
 dependencies = [
  "arrayref",
- "arrayvec 0.7.4",
+ "arrayvec 0.7.6",
  "cc",
- "cfg-if 1.0.0",
+ "cfg-if",
  "constant_time_eq",
+ "cpufeatures",
 ]
 
 [[package]]
@@ -356,6 +464,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-buffer"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96eb4cdd6cf1b31d671e9efe75c5d1ec614776856cefbe109ca373554a6d514f"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "bstr"
 version = "0.2.17"
@@ -369,12 +486,12 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.9.1"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
  "memchr",
- "regex-automata 0.4.7",
+ "regex-automata 0.4.13",
  "serde",
 ]
 
@@ -388,37 +505,46 @@ dependencies = [
 ]
 
 [[package]]
-name = "build_const"
-version = "0.2.2"
+name = "bumpalo"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ae4235e6dac0694637c763029ecea1a2ec9e4e06ec2729bd21ba4d9c863eb7"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+dependencies = [
+ "allocator-api2",
+]
 
 [[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"
-version = "0.6.12"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+checksum = "0caa33a2c0edca0419d15ac723dff03f1956f7978329b1e3b5fdaaaed9d3ca8b"
 dependencies = [
  "bytecheck_derive",
  "ptr_meta",
+ "rancor",
  "simdutf8",
 ]
 
 [[package]]
 name = "bytecheck_derive"
-version = "0.6.12"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -429,62 +555,76 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "0.4.12"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 dependencies = [
- "byteorder",
- "iovec",
+ "serde",
 ]
 
 [[package]]
-name = "bytes"
-version = "1.6.1"
+name = "bytesize"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
+checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "bytesize"
-version = "1.3.0"
+name = "camino"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "camino"
-version = "1.1.7"
+name = "cargo-platform"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.8"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87a0c0e6148f11f01f32650a2ea02d532b2ad4e81d8bd41e6e565b5adc5e6082"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
 dependencies = [
+ "camino",
+ "cargo-platform 0.1.9",
+ "semver 1.0.27",
  "serde",
+ "serde_json",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "cargo_metadata"
-version = "0.15.4"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
+checksum = "ef987d17b0a113becdd19d3d0022d04d7ef41f9efe4f3fb63ac44ba61df3ade9"
 dependencies = [
  "camino",
- "cargo-platform",
- "semver 1.0.23",
+ "cargo-platform 0.3.2",
+ "semver 1.0.27",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -495,62 +635,66 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cbindgen"
-version = "0.24.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b922faaf31122819ec80c4047cc684c6979a087366c069611e33649bf98e18d"
+checksum = "befbfd072a8e81c02f8c507aefce431fe5e7d051f83d48a23ffc9b9fe5a11799"
 dependencies = [
- "heck 0.4.1",
- "indexmap 1.9.3",
- "log 0.4.22",
+ "heck 0.5.0",
+ "indexmap",
+ "log",
  "proc-macro2",
  "quote",
  "serde",
  "serde_json",
- "syn 1.0.109",
+ "syn 2.0.114",
  "tempfile",
- "toml 0.5.11",
+ "toml",
 ]
 
 [[package]]
 name = "cc"
-version = "1.1.6"
+version = "1.2.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
+checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583"
 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.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[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.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -577,24 +721,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
  "ciborium-io",
- "half 2.4.1",
+ "half 2.7.1",
 ]
 
 [[package]]
-name = "cipher"
-version = "0.4.4"
+name = "clang-sys"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
- "crypto-common",
- "inout",
+ "glob",
+ "libc",
+ "libloading",
 ]
 
 [[package]]
 name = "clap"
-version = "4.4.11"
+version = "4.5.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfaff671f6b22ca62406885ece523383b9b64022e341e53e009a62ebc47a45f2"
+checksum = "3e34525d5bbbd55da2bb745d34b36121baac88d07619a9a09cfcf4a6c0832785"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -602,181 +747,234 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.11"
+version = "4.5.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a216b506622bb1d316cd51328dce24e07bdff4a6128a47c7e7fad11878d5adbb"
+checksum = "59a20016a20a3da95bef50ec7238dbd09baeef4311dcdd38ec15aba69812fb61"
 dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim 0.10.0",
+ "strsim 0.11.1",
 ]
 
 [[package]]
 name = "clap_complete"
-version = "4.5.3"
+version = "4.5.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5a2d6eec27fce550d708b2be5d798797e5a55b246b323ef36924a0001996352"
+checksum = "430b4dc2b5e3861848de79627b2bedc9f3342c7da5173a14eaa5d0f8dc18ae5d"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.4.7"
+version = "4.5.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
 dependencies = [
- "heck 0.4.1",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.6.0"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
 
 [[package]]
 name = "clap_mangen"
-version = "0.2.22"
+version = "0.2.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f50dde5bc0c853d6248de457e5eb6e5a674a54b93810a34ded88d882ca1fe2de"
+checksum = "439ea63a92086df93893164221ad4f24142086d535b3a0957b9b9bea2dc86301"
 dependencies = [
  "clap",
  "roff",
 ]
 
 [[package]]
-name = "cloudabi"
-version = "0.0.3"
+name = "cmake"
+version = "0.1.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
 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"
-version = "1.9.4"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f741c91823341bebf717d4c71bda820630ce065443b58bd1b7451af008355"
+checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
 dependencies = [
- "is-terminal",
- "lazy_static",
- "winapi 0.3.9",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "colored"
-version = "2.1.0"
+name = "comfy-table"
+version = "7.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
+checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
 dependencies = [
- "lazy_static",
- "windows-sys 0.48.0",
+ "crossterm",
+ "unicode-segmentation",
+ "unicode-width",
 ]
 
 [[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",
-]
-
-[[package]]
-name = "comfy-table"
-version = "7.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
-dependencies = [
- "crossterm",
- "strum",
- "strum_macros",
- "unicode-width",
-]
-
-[[package]]
-name = "compiler-test-derive"
-version = "0.0.1"
+name = "compiler-test-derive"
+version = "0.0.1"
 dependencies = [
  "pretty_assertions",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
  "trybuild",
 ]
 
 [[package]]
 name = "compiletest_rs"
-version = "0.6.0"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0086d6ad78cf409c3061618cd98e2789d5c9ce598fc9651611cf62eae0a599cb"
+checksum = "f150fe9105fcd2a57cad53f0c079a24de65195903ef670990f5909f695eac04c"
 dependencies = [
  "diff",
  "filetime",
  "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",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "compression-codecs"
+version = "0.4.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00828ba6fd27b45a448e57dbfe84f1029d4c9f26b368157e9a448a5f49a2ec2a"
+dependencies = [
+ "compression-core",
+ "flate2",
+ "memchr",
+ "zstd",
+ "zstd-safe",
+]
+
+[[package]]
+name = "compression-core"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "console"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e45a4a8926227e4197636ba97a9fc9b00477e9f4bd711395687c5f0734bec4"
 dependencies = [
  "encode_unicode",
- "lazy_static",
  "libc",
+ "once_cell",
  "unicode-width",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "console_error_panic_hook"
-version = "0.1.7"
+name = "console-api"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+checksum = "e8599749b6667e2f0c910c1d0dff6901163ff698a52d5a39720f61b5be4b20d3"
 dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen",
+ "futures-core",
+ "prost",
+ "prost-types",
+ "tonic",
+ "tonic-prost",
+ "tracing-core",
+]
+
+[[package]]
+name = "console-subscriber"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb4915b7d8dd960457a1b6c380114c2944f728e7c65294ab247ae6b6f1f37592"
+dependencies = [
+ "console-api",
+ "crossbeam-channel",
+ "crossbeam-utils",
+ "futures-task",
+ "hdrhistogram",
+ "humantime",
+ "hyper-util",
+ "prost",
+ "prost-types",
+ "serde",
+ "serde_json",
+ "thread_local",
+ "tokio",
+ "tokio-stream",
+ "tonic",
+ "tracing",
+ "tracing-core",
+ "tracing-subscriber",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
 [[package]]
 name = "constant_time_eq"
-version = "0.3.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
 
 [[package]]
 name = "convert_case"
-version = "0.4.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
 
 [[package]]
 name = "cooked-waker"
@@ -794,165 +992,209 @@ 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.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e"
+checksum = "2b2b4c7e3e97730e6b0b8c5ff5ca82c663d1a645e4f630f4fa4c24e80626787e"
 dependencies = [
  "autocfg",
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
  "scopeguard",
- "windows-sys 0.33.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "counter"
-version = "0.5.7"
+name = "cpufeatures"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d458e66999348f56fd3ffcfbb7f7951542075ca8359687c703de6500c1ddccd"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
- "num-traits",
+ "libc",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.2.12"
+name = "cranelift-assembler-x64"
+version = "0.128.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "d32b9105ce689b3e79ae288f62e9c2d0de66e4869176a11829e5c696da0f018f"
 dependencies = [
- "libc",
+ "cranelift-assembler-x64-meta",
+]
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.128.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e950e8dd96c1760f1c3a2b06d3d35584a3617239d034e73593ec096a1f3ea69"
+dependencies = [
+ "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.91.1"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2ab4512dfd3a6f4be184403a195f76e81a8a9f9e6c898e19d2dc3ce20e0115"
+checksum = "aea7351476d0eb196e89150e7a6235ecd37c97848243faea7746c29676abeeac"
 dependencies = [
  "cranelift-entity",
 ]
 
+[[package]]
+name = "cranelift-bitset"
+version = "0.128.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94d37c4589e52def48bd745c3b28b523d66ade8b074644ed3a366144c225f212"
+
 [[package]]
 name = "cranelift-codegen"
-version = "0.91.1"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98b022ed2a5913a38839dfbafe6cf135342661293b08049843362df4301261dc"
+checksum = "fa9e80ceb5153bb9dd0d048e685ec4df6fa20ce92d4ffffcb5d691623e1d8693"
 dependencies = [
- "arrayvec 0.7.4",
  "bumpalo",
+ "cranelift-assembler-x64",
  "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",
+ "hashbrown 0.15.5",
+ "log",
+ "pulley-interpreter",
  "regalloc2",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "rustc-hash",
+ "serde",
+ "smallvec",
+ "target-lexicon 0.13.4",
+ "wasmtime-internal-math",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.91.1"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "639307b45434ad112a98f8300c0f0ab085cbefcd767efcdef9ef19d4c0756e74"
+checksum = "9e5131015cf909d631a2afb1a3fd6bf6dbe08d896bc984a029dcbbe4a271f8dc"
 dependencies = [
+ "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck 0.5.0",
+ "pulley-interpreter",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.91.1"
+version = "0.128.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278e52e29c53fcf32431ef08406c295699a70306d05a0715c5b1bf50e33a9ab7"
+checksum = "a068c67f04f37de835fda87a10491e266eea9f9283d0887d8bd0a2c0726588a9"
 
 [[package]]
-name = "cranelift-egraph"
-version = "0.91.1"
+name = "cranelift-control"
+version = "0.128.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624b54323b06e675293939311943ba82d323bb340468ce1889be5da7932c8d73"
+checksum = "35ceb830549fcd7f05493a3b6d3d2bcfa4d43588b099e8c2393d2d140d6f7951"
 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.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a59bcbca89c3f1b70b93ab3cbba5e5e0cbf3e63dadb23c7525cb142e21a9d4c"
+checksum = "3e57c6f29da407f6ee9956197d011aedf4fd39bd03781ab5b44b85d45a448a27"
+dependencies = [
+ "cranelift-bitset",
+]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.91.1"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d70abacb8cfef3dc8ff7e8836e9c1d70f7967dfdac824a4cd5e30223415aca6"
+checksum = "add3991ccfeb20022443bae60b8adc56081f27caab0213b0ff26288954e44fe5"
 dependencies = [
  "cranelift-codegen",
- "hashbrown 0.12.3",
- "log 0.4.22",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "hashbrown 0.15.5",
+ "log",
+ "smallvec",
+ "target-lexicon 0.13.4",
 ]
 
 [[package]]
 name = "cranelift-isle"
-version = "0.91.1"
+version = "0.128.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc02707039d43c0e132526f1d3ac319b45468331b823a1749625825010f644e4"
+
+[[package]]
+name = "cranelift-srcgen"
+version = "0.128.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "393bc73c451830ff8dbb3a07f61843d6cb41a084f9996319917c0b291ed785bb"
+checksum = "15a4849e90e778f2fcc9fd1b93bd074dbf6b8b6f420951f9617c4774fe71e7fc"
 
 [[package]]
 name = "crc"
-version = "1.8.1"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d663548de7f5cca343f1e0a48d14dcfb0e9eb4e079ec58883b7251539fa10aeb"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
 dependencies = [
- "build_const",
+ "crc-catalog",
 ]
 
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
 ]
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "4d883447757bb0ee46f233e9dc22eb84d93a9508c9b868687b274fc431d886bf"
 dependencies = [
+ "alloca",
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
- "itertools 0.10.5",
+ "csv",
+ "itertools 0.13.0",
  "num-traits",
- "once_cell",
  "oorandom",
+ "page_size",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -960,63 +1202,31 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "ed943f81ea2faa8dcecbbfa50164acf95d555afec96a27871663b300e387b2e4"
 dependencies = [
  "cast",
- "itertools 0.10.5",
+ "itertools 0.13.0",
 ]
 
-[[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"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
- "crossbeam-utils 0.8.20",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20ff29ded3204c5106278a81a38f4b482636ed4fa1e6cfbeef193291beb29ed"
-dependencies = [
- "crossbeam-epoch 0.8.2",
- "crossbeam-utils 0.7.2",
- "maybe-uninit",
-]
-
-[[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 +1235,36 @@ 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.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.10.0",
  "crossterm_winapi",
- "libc",
- "parking_lot 0.12.3",
- "winapi 0.3.9",
+ "document-features",
+ "parking_lot",
+ "rustix",
+ "winapi",
 ]
 
 [[package]]
@@ -1084,40 +1273,60 @@ 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"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "typenum",
 ]
 
 [[package]]
-name = "ctor"
-version = "0.1.26"
+name = "crypto-common"
+version = "0.2.0-rc.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
+checksum = "c7722afd27468475c9b6063dc03a57ef2ca833816981619f8ebe64d38d207eef"
 dependencies = [
- "quote",
- "syn 1.0.109",
+ "hybrid-array",
+]
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
 ]
 
 [[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,239 +1334,262 @@ 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.114",
+ "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",
  "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.114",
 ]
 
 [[package]]
 name = "darling"
-version = "0.14.4"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
 dependencies = [
- "darling_core 0.14.4",
- "darling_macro 0.14.4",
+ "darling_core 0.20.11",
+ "darling_macro 0.20.11",
 ]
 
 [[package]]
 name = "darling"
-version = "0.20.10"
+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]]
 name = "darling_core"
-version = "0.14.4"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
+ "strsim 0.11.1",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "darling_core"
-version = "0.20.10"
+version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim 0.11.1",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.14.4"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
- "darling_core 0.14.4",
+ "darling_core 0.20.11",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.10"
+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.114",
 ]
 
 [[package]]
 name = "dashmap"
-version = "5.5.3"
+version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
- "cfg-if 1.0.0",
+ "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 = "dashmap"
-version = "6.0.1"
+name = "data-encoding"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "804c8821570c3f8b70230c2ba75ffa5c0f9a4189b9a432b6656c536712acae28"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils 0.8.20",
- "hashbrown 0.14.5",
- "lock_api 0.4.12",
- "once_cell",
- "parking_lot_core 0.9.10",
-]
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
 
 [[package]]
-name = "data-encoding"
-version = "2.6.0"
+name = "defmt"
+version = "0.3.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
+checksum = "f0963443817029b2024136fc4dd07a5107eb8f977eaf18fcd1fdeb11306b64ad"
+dependencies = [
+ "defmt 1.0.1",
+]
 
 [[package]]
-name = "deranged"
-version = "0.3.11"
+name = "defmt"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "548d977b6da32fa1d1fda2876453da1e7df63ad0304c8b3dae4dbe7b96f39b78"
 dependencies = [
- "powerfmt",
- "serde",
+ "bitflags 1.3.2",
+ "defmt-macros",
 ]
 
 [[package]]
-name = "derivative"
-version = "2.2.0"
+name = "defmt-macros"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+checksum = "3d4fc12a85bcf441cfe44344c4b72d58493178ce635338a3f3b78943aceb258e"
 dependencies = [
+ "defmt-parser",
+ "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+dependencies = [
+ "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.114",
 ]
 
 [[package]]
 name = "derive_builder"
-version = "0.12.0"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d67778784b508018359cbc8696edb3db78160bab2c2a28ba7f56ef6932997f8"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
 dependencies = [
  "derive_builder_macro",
 ]
 
 [[package]]
 name = "derive_builder_core"
-version = "0.12.0"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c11bdc11a0c47bc7d37d582b5285da6849c96681023680b906673c5707af7b0f"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
 dependencies = [
- "darling 0.14.4",
+ "darling 0.20.11",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "derive_builder_macro"
-version = "0.12.0"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebcda35c7a396850a55ffeac740804b40ffec779b98fffbb1738f4033f0ee79e"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
 dependencies = [
  "derive_builder_core",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "derive_more"
-version = "0.99.18"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
 dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
- "rustc_version 0.4.0",
- "syn 2.0.72",
+ "rustc_version 0.4.1",
+ "syn 2.0.114",
+ "unicode-xid",
 ]
 
 [[package]]
 name = "dialoguer"
-version = "0.11.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "658bce805d770f407bc62102fca7c2c64ceef2fbcb2b8bd19d2765ce093980de"
+checksum = "25f104b501bf2364e78d0d3974cbc774f738f5865306ed128e1e0d7499c0ad96"
 dependencies = [
- "console",
+ "console 0.16.2",
  "shell-words",
  "tempfile",
- "thiserror",
  "zeroize",
 ]
 
@@ -1379,16 +1611,26 @@ version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "block-buffer",
- "crypto-common",
- "subtle",
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff8de092798697546237a3a701e4174fe021579faec9b854379af9bf1e31962"
+dependencies = [
+ "block-buffer 0.11.0",
+ "const-oid",
+ "crypto-common 0.2.0-rc.13",
 ]
 
 [[package]]
 name = "dirs"
-version = "4.0.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
 dependencies = [
  "dirs-sys",
 ]
@@ -1399,19 +1641,20 @@ 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",
 ]
 
 [[package]]
 name = "dirs-sys"
-version = "0.3.7"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 dependencies = [
  "libc",
- "redox_users",
- "winapi 0.3.9",
+ "option-ext",
+ "redox_users 0.5.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1421,8 +1664,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 dependencies = [
  "libc",
- "redox_users",
- "winapi 0.3.9",
+ "redox_users 0.4.6",
+ "winapi",
 ]
 
 [[package]]
@@ -1433,26 +1676,20 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
-[[package]]
-name = "distance"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9d8664cf849d7d0f3114a3a387d2f5e4303176d746d5a951aaddc66dfe9240"
-
 [[package]]
 name = "doc-comment"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9"
 
 [[package]]
 name = "document-features"
-version = "0.2.10"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 dependencies = [
  "litrs",
 ]
@@ -1465,232 +1702,212 @@ checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
 
 [[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.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b"
+checksum = "d36219658beb39702975c707dee7895943ca281ca46eebbc5ea395171b9c182b"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "byteorder",
  "lazy_static",
- "proc-macro-error",
+ "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "dynasmrt"
-version = "1.2.3"
+version = "4.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9"
+checksum = "2bc32ed2a02b82bc43a7631dd624e8c5731a8377e40a468da28e62fc2e028952"
 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.9",
 ]
 
 [[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.114",
 ]
 
 [[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"
-version = "0.7.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
+checksum = "a4549325971814bda7a44061bf3fe7e487d447cba01e4220a4b454d630d7a016"
 dependencies = [
  "enum-iterator-derive",
 ]
 
 [[package]]
 name = "enum-iterator-derive"
-version = "0.7.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
+checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "enum-ordinalize"
-version = "3.1.15"
+version = "4.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bf1fa3f06bbff1ea5b1a9c7b14aa992a39657db60a2759457328d7e058f49ee"
+checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
 dependencies = [
- "num-bigint",
- "num-traits",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[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.114",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
+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"
-version = "0.3.31"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c"
+checksum = "89e8918065695684b2b0702da20382d5ae6065cf3327bc2d6436bd49a71ce9f3"
 dependencies = [
  "serde",
+ "serde_core",
+ "typeid",
 ]
 
 [[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 = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
 
 [[package]]
-name = "fastrand"
-version = "2.1.0"
+name = "fallible-iterator"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
-name = "fern"
-version = "0.6.2"
+name = "fastrand"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9f0c14694cbd524c8720dd69b0e3179344f04ebb5f90f2e4a440c6ea3b2f1ee"
-dependencies = [
- "colored 1.9.4",
- "log 0.4.22",
-]
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "field-offset"
@@ -1699,35 +1916,47 @@ 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.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
- "redox_syscall 0.4.1",
- "windows-sys 0.52.0",
+ "libredox",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db"
+
 [[package]]
 name = "fixedbitset"
-version = "0.4.2"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flagset"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
 
 [[package]]
 name = "flate2"
-version = "1.0.30"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
+ "zlib-rs",
 ]
 
 [[package]]
@@ -1739,12 +1968,33 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -1762,65 +2012,33 @@ 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_extra"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
-
-[[package]]
-name = "fuchsia-zircon"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
-dependencies = [
- "bitflags 1.3.2",
- "fuchsia-zircon-sys",
-]
-
-[[package]]
-name = "fuchsia-zircon-sys"
-version = "0.3.3"
-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"
+name = "fs-err"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e57070510966bfef93662a81cb8aa2b1c7db0964354fa9921434f04b9e8660"
+checksum = "88a41f105fe1d5b6b34b2055e3dc59bb79b46b48b2040b9e6c7b4b5de097aa41"
 dependencies = [
- "libc",
- "log 0.3.9",
- "pkg-config",
- "thread-scoped",
- "time 0.1.45",
+ "autocfg",
 ]
 
 [[package]]
-name = "futures"
-version = "0.1.31"
+name = "fs_extra"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
 [[package]]
 name = "futures"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1833,9 +2051,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 +2061,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 +2078,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.114",
 ]
 
 [[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 +2142,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,166 +2154,157 @@ 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",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "js-sys",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi",
  "wasm-bindgen",
 ]
 
 [[package]]
-name = "ghost"
-version = "0.1.17"
+name = "getrandom"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0e085ded9f1267c32176b40921b9754c474f7dd96f7e808d4a982e48aa1e854"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.72",
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.26.2"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 dependencies = [
  "fallible-iterator",
- "indexmap 1.9.3",
+ "indexmap",
  "stable_deref_trait",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.29.0"
+name = "git-version"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19"
+dependencies = [
+ "git-version-macro",
+]
 
 [[package]]
-name = "glob"
-version = "0.3.1"
+name = "git-version-macro"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
 
 [[package]]
-name = "globset"
-version = "0.4.14"
+name = "glob"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1"
-dependencies = [
- "aho-corasick",
- "bstr 1.9.1",
- "log 0.4.22",
- "regex-automata 0.4.7",
- "regex-syntax 0.8.4",
-]
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
-name = "graphql-introspection-query"
-version = "0.2.0"
+name = "globset"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2a4732cf5140bd6c082434494f785a19cfb566ab07d1382c3671f5812fed6d"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
 dependencies = [
- "serde",
+ "aho-corasick",
+ "bstr 1.12.1",
+ "log",
+ "regex-automata 0.4.13",
+ "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.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db7802310624d21a55797a3bc442dbe405424e9b2c967f86fb415634976f9a97"
+checksum = "a7c12b734aef65c081d988163f5a3b8991f4193c837aa5bfdcad96630e4f2385"
 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",
+ "thiserror 2.0.18",
  "tungstenite",
 ]
 
 [[package]]
-name = "graphql_client"
-version = "0.13.0"
+name = "gumdrop"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cdf7b487d864c2939b23902291a5041bc4a84418268f25fda1c8d4e15ad8fa"
+checksum = "5bc700f989d2f6f0248546222d9b4258f5b02a171a431f8285a81c08142629e3"
 dependencies = [
- "graphql_query_derive",
- "serde",
- "serde_json",
+ "gumdrop_derive",
 ]
 
 [[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"
+name = "gumdrop_derive"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00bda454f3d313f909298f626115092d348bc231025699f557b27e248475f48c"
+checksum = "729f9bd3449d77e7831a18abfb7ba2f99ee813dfd15b8c2167c9a54ba20aa99d"
 dependencies = [
- "graphql_client_codegen",
  "proc-macro2",
+ "quote",
  "syn 1.0.109",
 ]
 
 [[package]]
-name = "gumdrop"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bc700f989d2f6f0248546222d9b4258f5b02a171a431f8285a81c08142629e3"
-dependencies = [
- "gumdrop_derive",
-]
-
-[[package]]
-name = "gumdrop_derive"
-version = "0.8.1"
+name = "h2"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729f9bd3449d77e7831a18abfb7ba2f99ee813dfd15b8c2167c9a54ba20aa99d"
+checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
 ]
 
 [[package]]
@@ -2096,12 +2315,13 @@ checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
 
 [[package]]
 name = "half"
-version = "2.4.1"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "crunchy",
+ "zerocopy",
 ]
 
 [[package]]
@@ -2110,7 +2330,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,60 +2346,69 @@ 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",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.11.2"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-dependencies = [
- "ahash 0.7.8",
-]
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "ahash 0.7.8",
+ "foldhash 0.1.5",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.14.5"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
- "ahash 0.8.11",
  "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.8.4"
+name = "hdrhistogram"
+version = "7.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+checksum = "765c9198f173dd59ce26ff9f95ef0aafd0a0fe01fb9d72841bc5066a4c06511d"
 dependencies = [
- "hashbrown 0.14.5",
+ "base64 0.21.7",
+ "byteorder",
+ "flate2",
+ "nom 7.1.3",
+ "num-traits",
 ]
 
 [[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 = [
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heapless"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af2455f757db2b292a9b1768c4b70186d443bcb3b316252d6b540aec1cd89ed"
 dependencies = [
- "atomic-polyfill",
  "hash32",
- "rustc_version 0.4.0",
- "spin",
  "stable_deref_trait",
 ]
 
@@ -2206,9 +2435,9 @@ 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,33 +2446,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "http"
-version = "0.2.12"
+name = "hexdump"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+checksum = "cf31ab66ed8145a1c7427bd8e9b42a6131bd74ccf444f69b9e620c2e73ded832"
 dependencies = [
- "bytes 1.6.1",
- "fnv",
- "itoa",
+ "arrayvec 0.5.2",
 ]
 
 [[package]]
 name = "http"
-version = "1.1.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
 dependencies = [
- "bytes 1.6.1",
- "fnv",
+ "bytes",
  "itoa",
 ]
 
@@ -2253,48 +2470,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 +2511,70 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "humantime"
-version = "2.1.0"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "b41fb3dc24fe72c2e3a4685eed55917c2fb228851257f4a8f2d985da9443c3e5"
+dependencies = [
+ "typenum",
+]
 
 [[package]]
 name = "hyper"
-version = "1.4.1"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
- "bytes 1.6.1",
+ "atomic-waker",
+ "bytes",
  "futures-channel",
- "futures-util",
- "http 1.1.0",
+ "futures-core",
+ "h2",
+ "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 1.0.5",
+]
+
+[[package]]
+name = "hyper-timeout"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
+dependencies = [
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
  "tower-service",
- "webpki-roots",
 ]
 
 [[package]]
@@ -2352,61 +2583,66 @@ 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",
 ]
 
 [[package]]
 name = "hyper-tungstenite"
-version = "0.13.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a343d17fe7885302ed7252767dc7bb83609a874b6ff581142241ec4b73957ad"
+checksum = "bc778da281a749ed28d2be73a9f2cd13030680a1574bc729debd1195e44f00e9"
 dependencies = [
  "http-body-util",
  "hyper",
  "hyper-util",
  "pin-project-lite",
- "tokio 1.38.1",
+ "tokio",
  "tokio-tungstenite",
  "tungstenite",
 ]
 
 [[package]]
 name = "hyper-util"
-version = "0.1.6"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956"
+checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
 dependencies = [
- "bytes 1.6.1",
+ "base64 0.22.1",
+ "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",
+ "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,11 +2656,92 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "id-arena"
-version = "2.2.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 
 [[package]]
 name = "ident_case"
@@ -2434,36 +2751,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.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b46810df39e66e925525d6e38ce1e7f6e1d208f72dc39757880fcb66e2c58af1"
+checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
 dependencies = [
- "crossbeam-deque 0.8.5",
+ "crossbeam-deque",
  "globset",
- "log 0.4.22",
+ "log",
  "memchr",
- "regex-automata 0.4.7",
+ "regex-automata 0.4.13",
  "same-file",
  "walkdir",
  "winapi-util",
@@ -2471,69 +2788,58 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
- "serde",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.2.6"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.16.1",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "indicatif"
-version = "0.17.8"
+version = "0.18.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
+checksum = "9375e112e4b463ec1b1c6c011953545c65a30164fbab5b581df32b3abf0dcb88"
 dependencies = [
- "console",
- "instant",
- "number_prefix",
+ "console 0.16.2",
  "portable-atomic",
  "unicode-width",
+ "unit-prefix",
+ "web-time",
 ]
 
 [[package]]
 name = "inkwell"
-version = "0.1.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbac11e485159a525867fb7e6aa61981453e6a72f625fde6a4ab3047b0c6dec9"
+checksum = "1def4112dfb2ce2993db7027f7acdb43c1f4ee1c70a082a2eef306ed5d0df365"
 dependencies = [
- "either",
  "inkwell_internals",
  "libc",
  "llvm-sys",
  "once_cell",
- "parking_lot 0.12.3",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "inkwell_internals"
-version = "0.7.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87d00c17e264ce02be5bc23d7bff959188ec7137beddd06b8b6b05a7c680ea85"
+checksum = "63736175c9a30ea123f7018de9f26163e0b39cd6978990ae486b510c4f3bad69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[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,44 +2854,27 @@ 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",
  "rustc_version 0.3.3",
 ]
 
-[[package]]
-name = "inout"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "insta"
-version = "1.39.0"
+version = "1.46.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810ae6042d48e2c9e9215043563a58a80b877bc863228a74cf10c49d4620a6f5"
+checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8"
 dependencies = [
- "console",
- "lazy_static",
- "linked-hash-map",
+ "console 0.15.11",
+ "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",
+ "tempfile",
 ]
 
 [[package]]
@@ -2594,7 +2883,7 @@ version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb6250a98af259a26fd5a4a6081fccea9ac116e4c3178acf4aeb86d32d2b7715"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.10.0",
  "cc",
  "handlebars",
  "lazy_static",
@@ -2606,45 +2895,43 @@ dependencies = [
 
 [[package]]
 name = "inventory"
-version = "0.2.3"
+version = "0.3.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84344c6e0b90a9e2b6f3f9abe5cc74402684e348df7b32adca28747e0cef091a"
+checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
 dependencies = [
- "ctor",
- "ghost",
+ "rustversion",
 ]
 
 [[package]]
-name = "iovec"
-version = "0.1.4"
+name = "ipnet"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
-dependencies = [
- "libc",
-]
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
 
 [[package]]
-name = "ipnet"
-version = "2.9.0"
+name = "iprange"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+checksum = "37209be0ad225457e63814401415e748e2453a5297f9b637338f5fb8afa4ec00"
+dependencies = [
+ "ipnet",
+]
 
 [[package]]
-name = "is-terminal"
-version = "0.4.12"
+name = "iri-string"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
 dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.52.0",
+ "memchr",
+ "serde",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itertools"
@@ -2657,54 +2944,55 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.12.1"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[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.4",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
 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 +3008,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 +3024,53 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[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.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
+ "bitflags 2.10.0",
+ "libc",
+ "redox_syscall 0.7.0",
 ]
 
+[[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 +3079,193 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linked_hash_set"
-version = "0.1.4"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
+checksum = "984fb35d06508d1e69fc91050cceba9c0b748f983e6739fa2c7a9237154c52c8"
 dependencies = [
  "linked-hash-map",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "litrs"
-version = "0.4.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "llvm-sys"
-version = "150.2.0"
+version = "211.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d6891afbe90a8be244f769dfe1db0b3c4880b8c44b12a6d0f7ab848d89b26d"
+checksum = "108b3ad2b2eaf2a561fc74196273b20e3436e4a688b8b44e250d83974dc1b2e2"
 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.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[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.114",
 ]
 
 [[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",
+ "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.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
 dependencies = [
  "twox-hash",
 ]
 
 [[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 = "mach2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
+
+[[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.18",
+ "zerocopy",
+ "zerocopy-derive",
+]
+
 [[package]]
 name = "macro-wasmer-universal-test"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "proc-macro2",
- "proc-quote",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -2948,45 +3276,30 @@ 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.13",
 ]
 
 [[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"
+name = "matchit"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 
 [[package]]
 name = "md5"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
+checksum = "ae960838283323069879657ca3de837e9f7bbb4c7bf6ea7f1b290d5e9476d2e0"
 
 [[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 +3311,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "memoffset"
-version = "0.5.6"
+name = "memmap2"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
 dependencies = [
- "autocfg",
+ "libc",
 ]
 
 [[package]]
@@ -3051,122 +3364,95 @@ dependencies = [
 ]
 
 [[package]]
-name = "minisign"
-version = "0.7.6"
+name = "minicov"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4225fad231f4cfb67990de1750bb53f10ff1d5b42b91beb2a49e6ebd36c9ab4a"
+checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d"
 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.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
- "log 0.4.22",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.48.0",
+ "log",
+ "wasi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "mio-uds"
-version = "0.6.8"
+name = "miow"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
+checksum = "536bfad37a309d62069485248eeaba1e8d9853aaf951caaeaed0585a95346f08"
 dependencies = [
- "iovec",
- "libc",
- "mio 0.6.23",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "miow"
-version = "0.2.2"
+name = "more-asserts"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
-dependencies = [
- "kernel32-sys",
- "net2",
- "winapi 0.2.8",
- "ws2_32-sys",
-]
+checksum = "1fafa6961cabd9c63bcd77a45d7e3b7f3b552b70417831fb0f56db717e72407e"
 
 [[package]]
-name = "miow"
-version = "0.3.7"
+name = "munge"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+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.114",
+]
 
 [[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-probe 0.1.6",
  "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 +3460,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 +3468,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.10.0",
+ "cfg-if",
  "cfg_aliases",
  "libc",
  "memoffset 0.9.1",
@@ -3199,11 +3485,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"
@@ -3212,47 +3507,27 @@ checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
 name = "normpath"
-version = "1.1.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec60c60a693226186f5d6edf073232bfb6464ed97eb22cf3b01c1e8198fd97f5"
+checksum = "bf23ab2b905654b4cb177e30b629937b3868311d4e1cba859f899c041046e69b"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[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.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "num-integer",
- "num-traits",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "num-conv"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
 
 [[package]]
 name = "num-traits"
@@ -3261,13 +3536,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
+ "libm",
 ]
 
 [[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,113 +3551,86 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.5.11"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.11"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
-[[package]]
-name = "number_prefix"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
-
 [[package]]
 name = "object"
-version = "0.28.4"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e42c982f2d955fac81dd7e1d0e1426a7d702acd9c98d19ab01083a6a0328c424"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "object"
-version = "0.29.0"
+version = "0.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
+checksum = "271638cd5fa9cca89c4c304675ca658efc4e64a66c716b7cfe1afb4b9611dbbc"
 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",
- "memchr",
-]
-
-[[package]]
-name = "object"
-version = "0.32.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
-dependencies = [
  "flate2",
+ "hashbrown 0.16.1",
+ "indexmap",
  "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.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[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"
-version = "0.6.1"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788"
+checksum = "a2fa337e0cf13357c13ef1dc108df1333eb192f75fc170bea03fcf1fd404c2ee"
 dependencies = [
- "bstr 1.9.1",
+ "bstr 1.12.1",
  "normpath",
- "winapi 0.3.9",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "openssl"
-version = "0.10.66"
+version = "0.10.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
 dependencies = [
- "bitflags 2.6.0",
- "cfg-if 1.0.0",
+ "bitflags 2.10.0",
+ "cfg-if",
  "foreign-types",
  "libc",
  "once_cell",
@@ -3397,20 +3646,26 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.5"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.103"
+version = "0.9.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
 dependencies = [
  "cc",
  "libc",
@@ -3418,11 +3673,17 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
 [[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 +3692,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.114",
 ]
 
 [[package]]
-name = "overload"
-version = "0.1.1"
+name = "page_size"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
 
 [[package]]
-name = "parking_lot"
-version = "0.9.0"
+name = "parking"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252"
-dependencies = [
- "lock_api 0.3.4",
- "parking_lot_core 0.6.3",
- "rustc_version 0.2.3",
-]
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
-dependencies = [
- "lock_api 0.4.12",
- "parking_lot_core 0.9.10",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.6.3"
+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 0.5.18",
+ "smallvec",
+ "windows-link",
 ]
 
 [[package]]
@@ -3512,42 +3756,31 @@ checksum = "17359afc20d7ab31fdb42bb844c8b3bb1dabd7dcf7e68428492da7f16966fcef"
 
 [[package]]
 name = "pathdiff"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
-
-[[package]]
-name = "pbkdf2"
-version = "0.12.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
-dependencies = [
- "digest",
- "hmac",
-]
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
 
 [[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.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
+checksum = "2c9eb05c21a464ea704b53158d358a31e6425db2f63a1a7312268b05fe2b75f7"
 dependencies = [
  "memchr",
- "thiserror",
  "ucd-trie",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.7.11"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
+checksum = "68f9dbced329c441fa79d80472764b1a2c7e57123553b8519b36663a2fb234ed"
 dependencies = [
  "pest",
  "pest_generator",
@@ -3555,63 +3788,107 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.11"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
+checksum = "3bb96d5051a78f44f43c8f712d8e810adb0ebf923fc9ed2655a7f66f63ba8ee5"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.11"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
+checksum = "602113b5b5e8621770cfd490cfd90b9f84ab29bd2b0e49ad83eb6d186cef2365"
 dependencies = [
- "once_cell",
  "pest",
- "sha2",
+ "sha2 0.10.9",
 ]
 
 [[package]]
 name = "petgraph"
-version = "0.6.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
  "fixedbitset",
- "indexmap 2.2.6",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "serde",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+ "serde",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher 1.0.2",
 ]
 
 [[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.114",
 ]
 
 [[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 +3898,30 @@ 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 = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
 [[package]]
 name = "portable-atomic"
-version = "1.7.0"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
 
 [[package]]
 name = "powerfmt"
@@ -3639,9 +3931,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",
+]
 
 [[package]]
 name = "predicates"
@@ -3650,7 +3945,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 +3954,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 +3968,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 +3984,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.114",
 ]
 
 [[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",
 ]
 
 [[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.114",
+]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
@@ -3754,53 +4050,61 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
  "version_check",
- "yansi 1.0.1",
+ "yansi",
 ]
 
 [[package]]
-name = "proc-quote"
-version = "0.4.0"
+name = "prost"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e84ab161de78c915302ca325a19bee6df272800e2ae1a43fe3ef430bab2a100"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
 dependencies = [
- "proc-macro-hack",
- "proc-macro2",
- "proc-quote-impl",
- "quote",
- "syn 1.0.109",
+ "bytes",
+ "prost-derive",
 ]
 
 [[package]]
-name = "proc-quote-impl"
-version = "0.3.2"
+name = "prost-derive"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fb3ec628b063cdbcf316e06a8b8c1a541d28fa6c0a8eacd2bfb2b7f49e88aa0"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
 dependencies = [
- "proc-macro-hack",
+ "anyhow",
+ "itertools 0.14.0",
  "proc-macro2",
  "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
+dependencies = [
+ "prost",
 ]
 
 [[package]]
 name = "ptr_meta"
-version = "0.1.4"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+checksum = "0b9a0cf95a1196af61d4f1cbdab967179516d9a4a4312af1f31948f8f6224a79"
 dependencies = [
  "ptr_meta_derive",
 ]
 
 [[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.114",
 ]
 
 [[package]]
@@ -3814,6 +4118,28 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "pulley-interpreter"
+version = "41.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5893776f2df13ad218c2055c8e1ec299f4d2d2270f73d2c67fc047da81feff12"
+dependencies = [
+ "cranelift-bitset",
+ "log",
+ "pulley-macros",
+]
+
+[[package]]
+name = "pulley-macros"
+version = "41.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af6fe011ea26b0b2c308918c6a1d11d44f688eb89d2ac0420b91340c495b4a90"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -3822,64 +4148,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",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.18",
+ "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.4",
+ "lru-slab",
+ "rand 0.9.2",
  "ring",
  "rustc-hash",
- "rustls 0.23.11",
+ "rustls",
+ "rustls-pki-types",
  "slab",
- "thiserror",
+ "thiserror 2.0.18",
  "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",
+ "tracing",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
 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",
+]
 
 [[package]]
 name = "rand"
@@ -3888,8 +4232,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.5",
 ]
 
 [[package]]
@@ -3899,7 +4253,17 @@ 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_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -3908,14 +4272,29 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
 ]
 
+[[package]]
+name = "rangemap"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "973443cf09a9c8656b574a866ab68dfa19f0867d0340648c7d2f6a71b8a8ea68"
+
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -3923,91 +4302,98 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
- "crossbeam-deque 0.8.5",
- "crossbeam-utils 0.8.20",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.1.57"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.10.0",
+]
 
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "49f3fe0889e69e2ae9e41f4d6c4c0181701d00e4697b356fb1f74173a5e0ee27"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.5.3"
+name = "redox_users"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "bitflags 2.6.0",
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.5"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.17",
  "libredox",
- "thiserror",
+ "thiserror 2.0.18",
 ]
 
 [[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.114",
 ]
 
 [[package]]
 name = "regalloc2"
-version = "0.5.1"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300d4fbfb40c1c66a78ba3ddd41c1110247cf52f97b87d0f2fc9209bd49b030c"
+checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa"
 dependencies = [
- "fxhash",
- "log 0.4.22",
- "slice-group-by",
- "smallvec 1.13.2",
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.15.5",
+ "log",
+ "rustc-hash",
+ "smallvec",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.7",
- "regex-syntax 0.8.4",
+ "regex-automata 0.4.13",
+ "regex-syntax",
 ]
 
 [[package]]
@@ -4015,32 +4401,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.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 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.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "region"
@@ -4050,204 +4433,151 @@ checksum = "e6b6ebd13bc009aef9cd476c1310d49ac354d36e240cf1bd753290f3dc7199a7"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
- "mach2",
+ "mach2 0.4.3",
  "windows-sys 0.52.0",
 ]
 
 [[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",
 ]
 
 [[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.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d6d2a27d57148378eb5e111173f4276ad26340ecc5c49a4a2152167a2d6a37"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
 dependencies = [
- "async-compression",
  "base64 0.22.1",
- "bytes 1.6.1",
+ "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",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots",
- "winreg",
+ "webpki-roots 1.0.5",
 ]
 
 [[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.17",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rkyv"
-version = "0.7.44"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0"
+checksum = "360b333c61ae24e5af3ae7c8660bd6b21ccd8200dbbc5d33c2454421e85b9c69"
 dependencies = [
- "bitvec",
  "bytecheck",
- "bytes 1.6.1",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
+ "bytes",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "munge",
  "ptr_meta",
+ "rancor",
  "rend",
  "rkyv_derive",
- "seahash",
  "tinyvec",
  "uuid",
 ]
 
 [[package]]
 name = "rkyv_derive"
-version = "0.7.44"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65"
+checksum = "7c02f8cdd12b307ab69fe0acf4cd2249c7460eb89dce64a0febadf934ebb6a9e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "rmp"
-version = "0.8.14"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "228ed7c16fa39782c3b3468e974aec2795e9089153cd08ee2e9aefb3613334c4"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
 dependencies = [
- "byteorder",
  "num-traits",
- "paste",
 ]
 
 [[package]]
 name = "rmp-serde"
-version = "0.15.5"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "723ecff9ad04f4ad92fe1c8ca6c20d2196d9286e9c60727c4cb5511629260e9d"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
 dependencies = [
- "byteorder",
  "rmp",
  "serde",
 ]
 
 [[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.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
-
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
+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,45 +4590,46 @@ 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]]
 name = "rustfix"
-version = "0.5.1"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2c50b74badcddeb8f7652fa8323ce440b95286f8e4b64ebfd871c609672704e"
+checksum = "82fa69b198d894d84e23afde8e9ab2af4400b2cba20d6bf2b428a8b01c222c5a"
 dependencies = [
- "anyhow",
- "log 0.4.22",
  "serde",
  "serde_json",
+ "thiserror 1.0.69",
+ "tracing",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.10.0",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.22.4"
+version = "0.23.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
 dependencies = [
- "log 0.4.22",
+ "log",
+ "once_cell",
  "ring",
  "rustls-pki-types",
  "rustls-webpki",
@@ -4307,54 +4638,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "rustls"
-version = "0.23.11"
+name = "rustls-native-certs"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4828ea528154ae444e5a642dbb7d5623354030dc9822b83fd9bb79683c7399d0"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "log 0.4.22",
- "once_cell",
- "ring",
+ "openssl-probe 0.2.1",
  "rustls-pki-types",
- "rustls-webpki",
- "subtle",
- "zeroize",
+ "schannel",
+ "security-framework 3.5.1",
 ]
 
 [[package]]
-name = "rustls-native-certs"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a88d6d420651b496bdd98684116959239430022a115c1240e6c3993be0b15fba"
-dependencies = [
- "openssl-probe",
- "rustls-pemfile",
- "rustls-pki-types",
- "schannel",
- "security-framework",
-]
-
-[[package]]
-name = "rustls-pemfile"
-version = "2.1.2"
+name = "rustls-pki-types"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
 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.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6b52d4fda176fd835fdc55a835d4a89b8499cad995885a21149d5ad62f852e"
+checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -4363,9 +4672,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 +4713,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",
@@ -4412,28 +4721,27 @@ dependencies = [
 
 [[package]]
 name = "ruzstd"
-version = "0.5.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
+checksum = "e5ff0cc5e135c8870a775d3320910cd9b564ec036b4dc0b8741629020be63f01"
 dependencies = [
- "byteorder",
- "derive_more",
  "twox-hash",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.18"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 
 [[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]]
@@ -4445,53 +4753,51 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "scc"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46e6f046b7fef48e2660c57ed794263155d713de679057f2d0c169bfc6e756cc"
+dependencies = [
+ "sdd",
+]
+
 [[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 = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92"
+checksum = "54e910108742c57a770f492731f99be216a52fadd361b06c8fb59d74ccc267d2"
 dependencies = [
  "dyn-clone",
+ "indexmap",
+ "ref-cast",
  "schemars_derive",
  "serde",
  "serde_json",
  "url",
- "uuid",
 ]
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.21"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e"
+checksum = "4908ad288c5035a8eb12cfdf0d49270def0a268ee162b75eeee0f85d155a7c45"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
-[[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 +4805,30 @@ 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 = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "sdd"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+checksum = "490dcfcbfef26be6800d11870ff2df8774fa6e86d047e3e8c8a76b25655e41ca"
 
 [[package]]
 name = "security-framework"
@@ -4521,37 +4836,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.10.0",
+ "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.10.0",
+ "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.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
+checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89"
 
 [[package]]
 name = "semver"
@@ -4559,47 +4878,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 +4923,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 +4941,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.114",
 ]
 
 [[package]]
@@ -4644,37 +4969,40 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
  "itoa",
- "ryu",
+ "memchr",
  "serde",
+ "serde_core",
+ "zmij",
 ]
 
 [[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 = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -4689,25 +5017,13 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_yaml"
-version = "0.8.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
-dependencies = [
- "indexmap 1.9.3",
- "ryu",
- "serde",
- "yaml-rust",
-]
-
 [[package]]
 name = "serde_yaml"
 version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap",
  "itoa",
  "ryu",
  "serde",
@@ -4716,27 +5032,25 @@ dependencies = [
 
 [[package]]
 name = "serial_test"
-version = "2.0.0"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e56dd856803e253c8f298af3f4d7eb0ae5e23a737252cd90bb4f3b435033b2d"
+checksum = "0d0b343e184fc3b7bb44dff0705fffcf4b3756ba6aff420dddd8b24ca145e555"
 dependencies = [
- "dashmap 5.5.3",
- "futures 0.3.30",
- "lazy_static",
- "log 0.4.22",
- "parking_lot 0.12.3",
+ "once_cell",
+ "parking_lot",
+ "scc",
  "serial_test_derive",
 ]
 
 [[package]]
 name = "serial_test_derive"
-version = "2.0.0"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f"
+checksum = "6f50427f258fb77356e4cd4aa0e87e2bd2c66dbcee41dc405282cae2bfc26c83"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -4745,20 +5059,31 @@ 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 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
  "cpufeatures",
- "digest",
+ "digest 0.10.7",
 ]
 
 [[package]]
 name = "sha2"
-version = "0.10.8"
+version = "0.11.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+checksum = "7535f94fa3339fe9e5e9be6260a909e62af97f6e14b32345ccf79b92b8b81233"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "cpufeatures",
- "digest",
+ "digest 0.11.0-rc.9",
 ]
 
 [[package]]
@@ -4776,111 +5101,102 @@ 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",
 ]
 
 [[package]]
 name = "shell-words"
-version = "1.1.0"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.2"
+version = "1.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
 dependencies = [
+ "errno",
  "libc",
 ]
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[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 = "slab"
-version = "0.4.9"
+name = "siphasher"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
-dependencies = [
- "autocfg",
-]
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
 [[package]]
-name = "slice-group-by"
-version = "0.3.1"
+name = "siphasher"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
 
 [[package]]
-name = "smallvec"
-version = "0.6.14"
+name = "slab"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97fcaeba89edba30f044a10c6a3cc39df9c3f17d7cd829dd1446cab35f890e0"
-dependencies = [
- "maybe-uninit",
-]
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "smawk"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 
 [[package]]
 name = "smoltcp"
-version = "0.8.2"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee34c1e1bfc7e9206cc0fb8030a90129b4e319ab53856249bb27642cab914fb3"
+checksum = "dad095989c1533c1c266d9b1e8d70a1329dd3723c3edac6d03bbd67e7bf6f4bb"
 dependencies = [
  "bitflags 1.3.2",
  "byteorder",
+ "cfg-if",
+ "defmt 0.3.100",
+ "heapless 0.8.0",
  "managed",
 ]
 
 [[package]]
 name = "socket2"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
-dependencies = [
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "socket2"
-version = "0.5.7"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
 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.60.2",
 ]
 
 [[package]]
@@ -4888,15 +5204,12 @@ 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"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "static_assertions"
@@ -4916,25 +5229,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 +5248,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.72"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc4b9b9bf2add8093d3f2c0204471e951b2285580335de42f9d2534f3ae7a8af"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4965,21 +5259,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.114",
+]
 
 [[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 +5296,27 @@ checksum = "422045212ea98508ae3d28025bc5aaa2bd4a9cdaecd442a08da2ee620ee9ea95"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
+
+[[package]]
+name = "target-triple"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b"
 
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
 dependencies = [
- "cfg-if 1.0.0",
  "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5018,7 +5327,7 @@ checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
 dependencies = [
  "dirs-next",
  "rustversion",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
@@ -5032,12 +5341,12 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.3.0"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
+checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
 dependencies = [
  "rustix",
- "windows-sys 0.48.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -5051,23 +5360,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.13.4",
 ]
 
 [[package]]
 name = "test-log"
-version = "0.2.16"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93"
+checksum = "37d53ac171c92a39e4769491c4b4dde7022c60042254b5fc044ae409d34a24d4"
 dependencies = [
  "test-log-macros",
  "tracing-subscriber",
@@ -5075,13 +5384,13 @@ dependencies = [
 
 [[package]]
 name = "test-log-macros"
-version = "0.2.16"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5"
+checksum = "be35209fd0781c5401458ab66e4f98accf63553e8fae7425503e92fdd319783b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -5090,91 +5399,112 @@ 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.63"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.69",
 ]
 
 [[package]]
-name = "thiserror-impl"
-version = "1.0.63"
+name = "thiserror"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.72",
+ "thiserror-impl 2.0.18",
 ]
 
 [[package]]
-name = "thread-scoped"
-version = "1.0.2"
+name = "thiserror-impl"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcbb6aa301e5d3b0b5ef639c9a9c7e2f1c944f177b460c04dc24c69b1fa2bd99"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
 
 [[package]]
-name = "thread_local"
-version = "1.1.8"
+name = "thiserror-impl"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
- "cfg-if 1.0.0",
- "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
 ]
 
 [[package]]
-name = "time"
-version = "0.1.45"
+name = "thread_local"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
- "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi 0.3.9",
+ "cfg-if",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.36"
+version = "0.3.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+checksum = "9da98b7d9b7dad93488a84b8248efc35352b0b2657397d4167e7ad67e5d535e5"
 dependencies = [
  "deranged",
  "itoa",
  "num-conv",
  "powerfmt",
- "serde",
+ "serde_core",
  "time-core",
  "time-macros",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.2"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
 name = "time-macros"
-version = "0.2.18"
+version = "0.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "78cc610bac2dcee56805c99642447d4c5dbde4d01f752ffea0199aee1f601dc4"
 dependencies = [
  "num-conv",
  "time-core",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -5187,9 +5517,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,143 +5530,33 @@ 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"
-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"
+version = "1.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
 dependencies = [
- "backtrace",
- "bytes 1.6.1",
+ "bytes",
  "libc",
- "mio 0.8.11",
- "num_cpus",
+ "mio",
+ "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.7",
+ "socket2",
  "tokio-macros",
- "windows-sys 0.48.0",
+ "tracing",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "tokio-codec"
-version = "0.1.2"
+name = "tokio-macros"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b"
-dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "tokio-io",
-]
-
-[[package]]
-name = "tokio-core"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87b1395334443abca552f63d4f61d0486f12377c2ba8b368e523f89e828cffd4"
-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",
-]
-
-[[package]]
-name = "tokio-current-thread"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de0e32a83f131e002238d7ccde18211c0a5397f60cbfffcb112868c2e0e20e"
-dependencies = [
- "futures 0.1.31",
- "tokio-executor",
-]
-
-[[package]]
-name = "tokio-executor"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb2d1b8f4548dbf5e1f7818512e9c406860678f29c300cdf0ebac72d1a3a1671"
-dependencies = [
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
-]
-
-[[package]]
-name = "tokio-fs"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4"
-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"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -5346,58 +5566,27 @@ 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",
+ "tokio",
 ]
 
 [[package]]
 name = "tokio-rustls"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
-dependencies = [
- "rustls 0.22.4",
- "rustls-pki-types",
- "tokio 1.38.1",
-]
-
-[[package]]
-name = "tokio-rustls"
-version = "0.26.0"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.11",
- "rustls-pki-types",
- "tokio 1.38.1",
+ "rustls",
+ "tokio",
 ]
 
 [[package]]
 name = "tokio-serde"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "911a61637386b789af998ee23f50aa30d5fd7edcec8d6d3dedae5e5815205466"
+checksum = "caf600e7036b17782571dd44fa0a5cea3c82f60db5137f774a325a76a0d6852b"
 dependencies = [
- "bincode",
- "bytes 1.6.1",
+ "bincode 1.3.3",
+ "bytes",
  "educe",
  "futures-core",
  "futures-sink",
@@ -5408,212 +5597,153 @@ dependencies = [
  "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"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
 dependencies = [
  "futures-core",
  "pin-project-lite",
- "tokio 1.38.1",
+ "tokio",
  "tokio-util",
 ]
 
-[[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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93044f2d313c95ff1cb7809ce9a7a05735b012288a888b62d4434fd58c94f296"
-dependencies = [
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
- "slab",
- "tokio-executor",
-]
-
 [[package]]
 name = "tokio-tungstenite"
-version = "0.21.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
  "futures-util",
- "log 0.4.22",
- "rustls 0.22.4",
+ "log",
+ "rustls",
  "rustls-native-certs",
  "rustls-pki-types",
- "tokio 1.38.1",
- "tokio-rustls 0.25.0",
+ "tokio",
+ "tokio-rustls",
  "tungstenite",
- "webpki-roots",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
-name = "tokio-udp"
-version = "0.1.6"
+name = "tokio-util"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "log 0.4.22",
- "mio 0.6.23",
- "tokio-codec",
- "tokio-io",
- "tokio-reactor",
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
-name = "tokio-uds"
-version = "0.2.7"
+name = "toml"
+version = "0.9.11+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab57a4ac4111c8c9dbcf70779f6fc8bc35ae4b2454809febac840ad19bd7e4e0"
+checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46"
 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",
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.7.11"
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 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.23.10+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
 dependencies = [
- "indexmap 1.9.3",
- "serde",
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
 ]
 
 [[package]]
-name = "toml"
-version = "0.8.15"
+name = "toml_parser"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
+checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit 0.22.16",
+ "winnow",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.6"
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
-dependencies = [
- "serde",
-]
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
 
 [[package]]
-name = "toml_edit"
-version = "0.19.15"
+name = "tonic"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+checksum = "eb7613188ce9f7df5bfe185db26c5814347d110db17920415cf2fbcad85e7203"
 dependencies = [
- "indexmap 2.2.6",
- "toml_datetime",
- "winnow 0.5.40",
+ "async-trait",
+ "axum",
+ "base64 0.22.1",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
+ "pin-project",
+ "socket2",
+ "sync_wrapper",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.22.16"
+name = "tonic-prost"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
+checksum = "66bd50ad6ce1252d87ef024b3d64fe4c3cf54a86fb9ef4c631fdd0ded7aeaa67"
 dependencies = [
- "indexmap 2.2.6",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow 0.6.15",
+ "bytes",
+ "prost",
+ "tonic",
 ]
 
 [[package]]
 name = "tower"
-version = "0.4.13"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
 dependencies = [
  "futures-core",
  "futures-util",
- "pin-project",
+ "indexmap",
  "pin-project-lite",
- "tokio 1.38.1",
+ "slab",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -5621,17 +5751,22 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.5.2"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
- "bitflags 2.6.0",
- "bytes 1.6.1",
+ "async-compression",
+ "bitflags 2.10.0",
+ "bytes",
+ "futures-core",
  "futures-util",
- "http 1.1.0",
+ "http",
  "http-body",
  "http-body-util",
+ "iri-string",
  "pin-project-lite",
+ "tokio",
+ "tokio-util",
  "tower",
  "tower-layer",
  "tower-service",
@@ -5640,23 +5775,23 @@ dependencies = [
 
 [[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.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
- "log 0.4.22",
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -5664,20 +5799,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.32"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
  "valuable",
@@ -5689,16 +5824,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 +5841,18 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.18"
+version = "0.3.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
 dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata 0.4.13",
  "serde",
  "serde_json",
  "sharded-slab",
- "smallvec 1.13.2",
+ "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
@@ -5743,7 +5878,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
 dependencies = [
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -5765,73 +5900,67 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "trybuild"
-version = "1.0.97"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b1e5645f2ee8025c2f1d75e1138f2dd034d74e6ba54620f3c569ba2a2a1ea06"
+checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335"
 dependencies = [
  "glob",
  "serde",
  "serde_derive",
  "serde_json",
+ "target-triple",
  "termcolor",
- "toml 0.8.15",
-]
-
-[[package]]
-name = "tun-tap"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a477a4e9367c72ac875d23cd07ac99ffa932497d8428767fed0cfa27bbabe50"
-dependencies = [
- "cc",
- "futures 0.1.31",
- "libc",
- "mio 0.6.23",
- "tokio-core",
+ "toml",
 ]
 
 [[package]]
 name = "tungstenite"
-version = "0.21.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 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.9.2",
+ "rustls",
  "rustls-pki-types",
  "sha1",
- "thiserror",
- "url",
+ "thiserror 2.0.18",
  "utf-8",
 ]
 
 [[package]]
 name = "twox-hash"
-version = "1.6.3"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
-dependencies = [
- "cfg-if 1.0.0",
- "static_assertions",
-]
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "typed-path"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3015e6ce46d5ad8751e4a772543a30c7511468070e98e64e20165f8f81155b64"
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
 [[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"
-version = "0.1.8"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4080564c5b2241b5bff53ab610082234e0c57b0417f4bd10596f183001505b8a"
+checksum = "be2212c8a9b9bcfca32024de14998494cf9a5dfa59ea1b829de98bac374b86bf"
 dependencies = [
  "erased-serde",
  "inventory",
@@ -5842,84 +5971,203 @@ dependencies = [
 
 [[package]]
 name = "typetag-impl"
-version = "0.1.8"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e60147782cc30833c05fba3bab1d9b5771b2685a2557672ac96fa5d154099c0e"
+checksum = "27a7a9b72ba121f6f1f6c3632b85604cac41aedb5ddc70accbebb6cac83de846"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
 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.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+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.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b55eedc365f81a3c32aea49baf23fa965e3cd85bcc28fb8045708c7388d124ef"
+checksum = "c866f627c3f04c3df068b68bb2d725492caaa539dd313e2a9d26bb85b1a32f4e"
+dependencies = [
+ "anyhow",
+ "cargo_metadata 0.19.2",
+ "uniffi_bindgen",
+ "uniffi_build",
+ "uniffi_core",
+ "uniffi_macros",
+ "uniffi_pipeline",
+]
 
 [[package]]
-name = "unreachable"
-version = "1.0.0"
+name = "uniffi_bindgen"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c8ca600167641ebe7c8ba9254af40492dda3397c528cc3b2f511bd23e8541a5"
+dependencies = [
+ "anyhow",
+ "askama",
+ "camino",
+ "cargo_metadata 0.19.2",
+ "fs-err",
+ "glob",
+ "goblin",
+ "heck 0.5.0",
+ "indexmap",
+ "once_cell",
+ "serde",
+ "tempfile",
+ "textwrap",
+ "toml",
+ "uniffi_internal_macros",
+ "uniffi_meta",
+ "uniffi_pipeline",
+ "uniffi_udl",
+]
+
+[[package]]
+name = "uniffi_build"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e55c05228f4858bb258f651d21d743fcc1fe5a2ec20d3c0f9daefddb105ee4d"
+dependencies = [
+ "anyhow",
+ "camino",
+ "uniffi_bindgen",
+]
+
+[[package]]
+name = "uniffi_core"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e7a5a038ebffe8f4cf91416b154ef3c2468b18e828b7009e01b1b99938089f9"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "once_cell",
+ "static_assertions",
+]
+
+[[package]]
+name = "uniffi_internal_macros"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c2a6f93e7b73726e2015696ece25ca0ac5a5f1cf8d6a7ab5214dd0a01d2edf"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "uniffi_macros"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64c6309fc36c7992afc03bc0c5b059c656bccbef3f2a4bc362980017f8936141"
+dependencies = [
+ "camino",
+ "fs-err",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.114",
+ "toml",
+ "uniffi_meta",
+]
+
+[[package]]
+name = "uniffi_meta"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+checksum = "0a138823392dba19b0aa494872689f97d0ee157de5852e2bec157ce6de9cdc22"
 dependencies = [
- "void",
+ "anyhow",
+ "siphasher 0.3.11",
+ "uniffi_internal_macros",
+ "uniffi_pipeline",
+]
+
+[[package]]
+name = "uniffi_pipeline"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c27c4b515d25f8e53cc918e238c39a79c3144a40eaf2e51c4a7958973422c29"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap",
+ "tempfile",
+ "uniffi_internal_macros",
 ]
 
+[[package]]
+name = "uniffi_udl"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0adacdd848aeed7af4f5af7d2f621d5e82531325d405e29463482becfdeafca"
+dependencies = [
+ "anyhow",
+ "textwrap",
+ "uniffi_meta",
+ "weedle2",
+]
+
+[[package]]
+name = "unit-prefix"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3"
+
+[[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"
@@ -5932,32 +6180,52 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
 [[package]]
 name = "ureq"
-version = "2.10.0"
+version = "3.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
+checksum = "d39cb1dbab692d82a977c0392ffac19e188bd9186a9f32806f0aaa859d75585a"
 dependencies = [
  "base64 0.22.1",
  "flate2",
- "log 0.4.22",
- "once_cell",
- "rustls 0.23.11",
+ "log",
+ "percent-encoding",
+ "rustls",
  "rustls-pki-types",
- "url",
- "webpki-roots",
+ "ureq-proto",
+ "utf-8",
+ "webpki-roots 1.0.5",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d81f9efa9df032be5934a46a068815a10a042b494b6a58cb0a1a97bb5467ed6f"
+dependencies = [
+ "base64 0.22.1",
+ "http",
+ "httparse",
+ "log",
 ]
 
 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna",
  "percent-encoding",
  "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -5972,6 +6240,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 +6254,20 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.10.0"
+version = "1.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f"
 dependencies = [
- "getrandom",
- "serde",
+ "getrandom 0.3.4",
+ "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 +6277,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.700.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bytes 1.6.1",
- "dashmap 6.0.1",
- "derivative",
+ "bytes",
+ "dashmap",
+ "derive_more",
  "dunce",
  "filetime",
  "fs_extra",
- "futures 0.3.30",
- "getrandom",
- "indexmap 1.9.3",
- "lazy_static",
+ "futures",
+ "getrandom 0.2.17",
+ "indexmap",
  "libc",
  "pin-project-lite",
  "pretty_assertions",
@@ -6030,54 +6304,59 @@ dependencies = [
  "shared-buffer",
  "slab",
  "tempfile",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 2.0.18",
+ "tokio",
  "tracing",
  "tracing-test",
  "typetag",
+ "virtual-mio",
+ "wasmer-package",
+ "web-time",
  "webc",
 ]
 
 [[package]]
 name = "virtual-mio"
-version = "0.3.1"
+version = "0.700.0"
 dependencies = [
  "async-trait",
- "bytes 1.6.1",
- "derivative",
- "futures 0.3.30",
- "mio 0.8.11",
+ "bytes",
+ "futures",
+ "mio",
+ "parking",
  "serde",
- "socket2 0.4.10",
- "thiserror",
+ "socket2",
+ "thiserror 2.0.18",
  "tracing",
 ]
 
 [[package]]
 name = "virtual-net"
-version = "0.8.0"
+version = "0.700.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64 0.21.7",
- "bincode",
+ "base64 0.22.1",
+ "bincode 2.0.1",
  "bytecheck",
- "bytes 1.6.1",
- "derivative",
+ "bytes",
+ "derive_more",
  "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",
+ "thiserror 2.0.18",
+ "tokio",
  "tokio-serde",
  "tokio-tungstenite",
  "tokio-util",
@@ -6087,10 +6366,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "void"
-version = "1.0.2"
+name = "virtue"
+version = "0.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
 
 [[package]]
 name = "wai-bindgen-gen-core"
@@ -6158,13 +6437,13 @@ dependencies = [
 
 [[package]]
 name = "wai-bindgen-wasmer"
-version = "0.27.0"
+version = "0.700.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "once_cell",
- "thiserror",
+ "thiserror 2.0.18",
  "tracing",
  "wai-bindgen-wasmer-impl",
  "wasmer",
@@ -6197,9 +6476,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",
 ]
@@ -6231,76 +6510,63 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-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 = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasi-test-generator"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "glob",
  "gumdrop",
  "serde",
  "serde_json",
  "tempfile",
- "wast 24.0.0",
+ "wast",
 ]
 
 [[package]]
-name = "wasite"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.92"
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
 dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen-macro",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.92"
+name = "wasm-bindgen"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
 dependencies = [
- "bumpalo",
- "log 0.4.22",
+ "cfg-if",
  "once_cell",
- "proc-macro2",
- "quote",
- "syn 2.0.72",
+ "rustversion",
+ "wasm-bindgen-macro",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
+ "futures-util",
  "js-sys",
+ "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -6308,53 +6574,70 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
- "wasm-bindgen-backend",
+ "syn 2.0.114",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.42"
+version = "0.3.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
+checksum = "45649196a53b0b7a15101d845d44d2dda7374fc1b5b5e2bbf58b7577ff4b346d"
 dependencies = [
- "console_error_panic_hook",
+ "async-trait",
+ "cast",
  "js-sys",
- "scoped-tls 1.0.1",
+ "libm",
+ "minicov",
+ "nu-ansi-term",
+ "num-traits",
+ "oorandom",
+ "serde",
+ "serde_json",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test-macro",
+ "wasm-bindgen-test-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.42"
+version = "0.3.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
+checksum = "f579cdd0123ac74b94e1a4a72bd963cf30ebac343f2df347da0b8df24cdebed2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
 ]
 
+[[package]]
+name = "wasm-bindgen-test-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8145dd1593bf0fb137dbfa85b8be79ec560a447298955877804640e40c2d6ea"
+
 [[package]]
 name = "wasm-coredump-builder"
-version = "0.1.22"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31ca262b320e4530a60946ba16a1cbf987d3f7d4aa6a953bfcc96e179e3e7458"
+checksum = "f1ece55555d4aab72d06f5ea7c871d46ac13b5fe6bcce0b4be8eec16728ddab0"
 dependencies = [
  "wasm-coredump-encoder",
  "wasm-coredump-types",
@@ -6363,9 +6646,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-coredump-encoder"
-version = "0.1.22"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f36ccfe604720ce093fce7d7b0d609c086c646ec4bb9bba58cb9f4dc2c5623"
+checksum = "03b53a32667c9a1384e4046c005dc8f3ea93f3319ca558fca85b00ce7d43d871"
 dependencies = [
  "leb128",
  "wasm-coredump-types",
@@ -6373,18 +6656,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-coredump-types"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2763d9807903c461b41275a13489396d04695d7bc365743b8ea430cfd72f336"
-
-[[package]]
-name = "wasm-encoder"
-version = "0.4.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b4949d4f2b25a4b208317dcf86aacef9e7a5884e48dfc45d4aeb91808d6f86"
-dependencies = [
- "leb128",
-]
+checksum = "67579a25309b5b9a805ec24fd6a8f5414293ae4adcda16970fa20b2f7c81fb79"
 
 [[package]]
 name = "wasm-encoder"
@@ -6397,30 +6671,31 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.32.0"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba64e81215916eaeb48fee292f29401d69235d62d8b8fd92a7b2844ec5ae5f7"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
 dependencies = [
- "leb128",
+ "leb128fmt",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
 name = "wasm-smith"
-version = "0.4.5"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e95fdeed16adeffed44efdc7ccf27d4f57ff2e99de417c75bcee7dee09049b"
+checksum = "c8f72462e1ee97c48da6f599c7e47064dbab12bfee7b4fad278de4973ba72fd8"
 dependencies = [
+ "anyhow",
  "arbitrary",
- "indexmap 1.9.3",
- "leb128",
- "wasm-encoder 0.4.1",
+ "flagset",
+ "wasm-encoder 0.244.0",
 ]
 
 [[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 +6706,35 @@ dependencies = [
 
 [[package]]
 name = "wasmer"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "anyhow",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
- "derivative",
- "hashbrown 0.11.2",
- "indexmap 1.9.3",
+ "bindgen",
+ "bytes",
+ "cfg-if",
+ "cmake",
+ "corosensei",
+ "derive_more",
+ "futures",
+ "hashbrown 0.16.1",
+ "indexmap",
  "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.13.4",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.18",
+ "tokio",
  "tracing",
+ "ureq",
  "wasm-bindgen",
  "wasm-bindgen-test",
  "wasmer-compiler",
@@ -6460,59 +6744,66 @@ dependencies = [
  "wasmer-derive",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.121.2",
+ "wasmi_c_api_impl",
+ "wasmparser 0.244.0",
  "wat",
- "windows-sys 0.59.0",
+ "which",
+ "windows-sys 0.61.2",
+ "xz",
+ "zip",
 ]
 
 [[package]]
-name = "wasmer-api"
-version = "0.0.34"
+name = "wasmer-argus"
+version = "7.0.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",
+ "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.700.0"
 dependencies = [
  "anyhow",
- "async-trait",
- "clap",
+ "async-tungstenite",
+ "base64 0.22.1",
  "cynic",
- "derive_more",
- "futures 0.3.30",
- "indicatif",
- "log 0.4.22",
+ "futures",
+ "getrandom 0.2.17",
+ "graphql-ws-client",
+ "harsh",
+ "merge-streams",
+ "pin-project-lite",
  "reqwest",
  "serde",
  "serde_json",
- "shared-buffer",
- "tokio 1.38.1",
+ "serde_path_to_error",
+ "time",
+ "tokio",
+ "tokio-tungstenite",
  "tracing",
- "tracing-subscriber",
  "url",
- "wasmer",
- "wasmer-api",
+ "uuid",
+ "wasmer-config",
+ "wasmer-package",
  "webc",
 ]
 
@@ -6534,18 +6825,17 @@ dependencies = [
 
 [[package]]
 name = "wasmer-c-api"
-version = "4.3.7"
+version = "7.0.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 2.0.18",
+ "tokio",
  "tracing",
  "tracing-subscriber",
  "typetag",
@@ -6555,7 +6845,6 @@ dependencies = [
  "wasmer-compiler-cranelift",
  "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
- "wasmer-emscripten",
  "wasmer-inline-c",
  "wasmer-middlewares",
  "wasmer-types",
@@ -6565,17 +6854,17 @@ dependencies = [
 
 [[package]]
 name = "wasmer-c-api-test-runner"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "cc",
  "regex",
- "target-lexicon 0.11.2",
+ "target-lexicon 0.13.4",
  "walkdir",
 ]
 
 [[package]]
 name = "wasmer-cache"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "blake3",
  "clap",
@@ -6584,95 +6873,93 @@ dependencies = [
  "clap_lex",
  "criterion",
  "hex",
- "rand",
+ "rand 0.9.2",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.18",
  "wasmer",
  "wasmer-compiler-singlepass",
 ]
 
 [[package]]
 name = "wasmer-capi-examples-runner"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "cc",
  "regex",
- "target-lexicon 0.11.2",
+ "target-lexicon 0.13.4",
  "walkdir",
 ]
 
 [[package]]
 name = "wasmer-cli"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.14",
+ "assert_cmd 2.1.2",
  "async-trait",
- "bytes 1.6.1",
+ "base64 0.22.1",
+ "bytes",
  "bytesize",
- "cargo_metadata",
- "cfg-if 1.0.0",
+ "cargo_metadata 0.23.1",
+ "cfg-if",
  "chrono",
  "clap",
  "clap_complete",
  "clap_mangen",
- "colored 2.1.0",
+ "colored",
  "comfy-table",
- "console",
+ "console 0.16.2",
+ "console-subscriber",
  "dialoguer",
  "dirs",
  "dotenvy",
- "edge-schema 0.1.0",
- "edge-util",
  "flate2",
- "fuse",
- "futures 0.3.30",
+ "futures",
  "futures-util",
+ "git-version",
  "hex",
- "http 1.1.0",
+ "http",
  "http-body-util",
  "humantime",
  "hyper",
  "hyper-util",
- "indexmap 1.9.3",
+ "indexmap",
  "indicatif",
  "interfaces",
- "is-terminal",
- "lazy_static",
+ "itertools 0.14.0",
  "libc",
- "log 0.4.22",
+ "log",
+ "lzma-rs",
  "mac_address",
- "mio 0.8.11",
+ "mio",
  "normpath",
- "object 0.32.2",
+ "object 0.38.1",
  "once_cell",
  "opener",
- "parking_lot 0.12.3",
+ "parking_lot",
+ "path-clean",
  "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",
- "sha2",
+ "serde_yaml",
+ "sha2 0.11.0-rc.4",
  "shared-buffer",
  "tar",
- "target-lexicon 0.12.15",
+ "target-lexicon 0.13.4",
  "tempfile",
- "thiserror",
- "time 0.1.45",
- "time 0.3.36",
- "tldextract",
- "tokio 1.38.1",
+ "thiserror 2.0.18",
+ "time",
+ "tokio",
  "tokio-tungstenite",
- "toml 0.5.11",
+ "toml",
  "tracing",
  "tracing-subscriber",
- "tun-tap",
  "unix_mode",
  "url",
  "uuid",
@@ -6682,15 +6969,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 +6987,56 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "backtrace",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
+ "bytes",
+ "cfg-if",
  "enum-iterator",
  "enumset",
- "hashbrown 0.11.2",
- "lazy_static",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
  "leb128",
  "libc",
- "memmap2 0.5.10",
+ "loupe",
+ "macho-unwind-info",
+ "memmap2 0.9.9",
  "more-asserts",
+ "object 0.38.1",
+ "rangemap",
  "region",
  "rkyv",
  "self_cell",
  "serde",
  "serde_bytes",
  "shared-buffer",
- "smallvec 1.13.2",
- "thiserror",
- "wasmer-object",
+ "smallvec",
+ "target-lexicon 0.13.4",
+ "tempfile",
+ "thiserror 2.0.18",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.121.2",
- "windows-sys 0.59.0",
- "xxhash-rust",
-]
-
-[[package]]
-name = "wasmer-compiler-cli"
-version = "4.3.7"
-dependencies = [
- "anyhow",
- "bytesize",
- "cfg-if 1.0.0",
- "clap",
- "colored 2.1.0",
- "distance",
- "fern",
- "is-terminal",
- "log 0.4.22",
- "target-lexicon 0.12.15",
- "unix_mode",
- "wasmer-compiler",
- "wasmer-compiler-cranelift",
- "wasmer-compiler-singlepass",
- "wasmer-types",
+ "wasmparser 0.244.0",
+ "which",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "wasmer-compiler-cranelift"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
  "cranelift-frontend",
- "gimli 0.26.2",
- "hashbrown 0.11.2",
- "lazy_static",
+ "gimli",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools 0.14.0",
+ "leb128",
  "more-asserts",
  "rayon",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "smallvec",
+ "target-lexicon 0.13.4",
  "tracing",
  "wasmer-compiler",
  "wasmer-types",
@@ -6772,21 +7044,22 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler-llvm"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "byteorder",
  "cc",
  "inkwell",
- "itertools 0.10.5",
- "lazy_static",
+ "itertools 0.14.0",
  "libc",
- "object 0.28.4",
+ "object 0.38.1",
+ "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.13.4",
+ "tracing",
  "wasmer-compiler",
  "wasmer-types",
  "wasmer-vm",
@@ -6794,90 +7067,56 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler-singlepass"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "byteorder",
  "dynasm",
  "dynasmrt",
  "enumset",
- "gimli 0.26.2",
- "hashbrown 0.11.2",
- "lazy_static",
+ "gimli",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
  "more-asserts",
  "rayon",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "smallvec",
+ "target-lexicon 0.13.4",
+ "tempfile",
  "wasmer-compiler",
  "wasmer-types",
 ]
 
 [[package]]
 name = "wasmer-config"
-version = "0.8.0"
+version = "0.700.0"
 dependencies = [
  "anyhow",
  "bytesize",
  "ciborium",
  "derive_builder",
  "hex",
- "indexmap 2.2.6",
+ "indexmap",
  "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 2.0.18",
+ "toml",
  "url",
 ]
 
 [[package]]
 name = "wasmer-derive"
-version = "4.3.7"
+version = "7.0.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",
+ "syn 2.0.114",
  "wasmer-types",
 ]
 
@@ -6911,48 +7150,46 @@ dependencies = [
 
 [[package]]
 name = "wasmer-integration-tests-cli"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.14",
- "derivative",
+ "assert_cmd 2.1.2",
  "dirs",
  "flate2",
- "futures 0.3.30",
+ "futures",
  "hex",
  "insta",
  "libc",
  "md5",
- "object 0.30.4",
+ "object 0.38.1",
  "once_cell",
- "predicates 2.1.5",
+ "predicates 3.1.3",
  "pretty_assertions",
- "rand",
+ "rand 0.9.2",
  "regex",
  "reqwest",
  "serde",
  "tar",
- "target-lexicon 0.12.15",
+ "target-lexicon 0.13.4",
  "tempfile",
- "tokio 1.38.1",
- "wasmer-registry",
+ "tokio",
 ]
 
 [[package]]
 name = "wasmer-integration-tests-ios"
-version = "4.3.7"
+version = "7.0.0"
 
 [[package]]
 name = "wasmer-journal"
-version = "0.9.0"
+version = "0.700.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64 0.21.7",
- "bincode",
+ "base64 0.22.1",
+ "bincode 2.0.1",
  "bytecheck",
- "bytes 1.6.1",
- "derivative",
+ "bytes",
+ "derive_more",
  "lz4_flex",
  "num_enum",
  "rkyv",
@@ -6960,18 +7197,19 @@ dependencies = [
  "serde_json",
  "shared-buffer",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.18",
  "tracing",
  "tracing-test",
  "virtual-fs",
  "virtual-net",
  "wasmer",
+ "wasmer-config",
  "wasmer-wasix-types",
 ]
 
 [[package]]
 name = "wasmer-middlewares"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "wasmer",
  "wasmer-types",
@@ -6979,66 +7217,81 @@ dependencies = [
 ]
 
 [[package]]
-name = "wasmer-object"
-version = "4.3.7"
+name = "wasmer-package"
+version = "0.700.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 0.11.0-rc.4",
+ "shared-buffer",
+ "tar",
+ "tempfile",
+ "thiserror 2.0.18",
+ "toml",
+ "ureq",
+ "url",
+ "wasmer-config",
  "wasmer-types",
+ "webc",
 ]
 
 [[package]]
-name = "wasmer-registry"
-version = "5.19.0"
+name = "wasmer-sdk"
+version = "7.0.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 0.11.0-rc.4",
  "tempfile",
- "thiserror",
- "time 0.3.36",
- "tldextract",
- "tokio 1.38.1",
- "tokio-tungstenite",
- "toml 0.5.11",
+ "thiserror 2.0.18",
+ "tokio",
+ "toml",
  "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.700.0"
+dependencies = [
+ "thiserror 2.0.18",
+ "tokio",
+ "uniffi",
+ "virtual-fs",
+ "wasmer",
+ "wasmer-package",
+ "wasmer-wasix",
  "webc",
- "whoami",
 ]
 
 [[package]]
 name = "wasmer-sys-utils"
-version = "0.27.0"
+version = "0.700.0"
 dependencies = [
  "libc",
  "region",
@@ -7052,82 +7305,91 @@ dependencies = [
 
 [[package]]
 name = "wasmer-types"
-version = "4.3.7"
+version = "7.0.0"
 dependencies = [
  "bytecheck",
  "enum-iterator",
  "enumset",
- "getrandom",
+ "getrandom 0.2.17",
  "hex",
- "indexmap 1.9.3",
+ "indexmap",
+ "loupe",
  "memoffset 0.9.1",
  "more-asserts",
  "rkyv",
  "serde",
  "serde_bytes",
- "sha2",
- "target-lexicon 0.12.15",
- "thiserror",
- "xxhash-rust",
+ "sha2 0.11.0-rc.4",
+ "target-lexicon 0.13.4",
+ "thiserror 2.0.18",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
 name = "wasmer-vm"
-version = "4.3.7"
+version = "7.0.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",
  "enum-iterator",
  "fnv",
- "indexmap 1.9.3",
- "lazy_static",
+ "gimli",
+ "indexmap",
  "libc",
- "mach2",
+ "libunwind",
+ "loupe",
+ "mach2 0.6.0",
  "memoffset 0.9.1",
  "more-asserts",
+ "parking_lot",
  "region",
+ "rustversion",
  "scopeguard",
  "serde",
- "thiserror",
+ "thiserror 2.0.18",
  "tracing",
  "wasmer-types",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "wasmer-wasix"
-version = "0.27.0"
+version = "0.700.0"
 dependencies = [
- "ahash 0.8.11",
  "anyhow",
+ "assert-panic",
  "async-trait",
- "base64 0.21.7",
- "bincode",
+ "base64 0.22.1",
+ "bincode 2.0.1",
  "blake3",
+ "bus",
  "bytecheck",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
+ "bytes",
+ "cfg-if",
  "chrono",
+ "ciborium",
  "cooked-waker",
- "dashmap 6.0.1",
- "derivative",
- "futures 0.3.30",
- "getrandom",
- "heapless",
+ "crossbeam-channel",
+ "dashmap",
+ "derive_more",
+ "env_logger",
+ "flate2",
+ "futures",
+ "getrandom 0.2.17",
+ "heapless 0.9.2",
  "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,25 +7397,25 @@ 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",
- "sha2",
+ "serde_yaml",
+ "sha2 0.11.0-rc.4",
  "shared-buffer",
  "tempfile",
  "terminal_size",
  "termios",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 2.0.18",
+ "tokio",
  "tokio-stream",
- "toml 0.8.15",
+ "toml",
  "tower",
  "tower-http",
  "tracing",
@@ -7170,33 +7432,36 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
+ "wasm-encoder 0.244.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.244.0",
+ "wcgi",
+ "wcgi-host",
  "web-sys",
  "webc",
  "weezl",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
  "xxhash-rust",
+ "zstd",
 ]
 
 [[package]]
 name = "wasmer-wasix-types"
-version = "0.27.0"
+version = "0.700.0"
 dependencies = [
  "anyhow",
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "byteorder",
- "cfg-if 1.0.0",
+ "cfg-if",
  "num_enum",
  "pretty_assertions",
  "serde",
- "time 0.3.36",
+ "time",
  "tracing",
  "wai-bindgen-gen-core",
  "wai-bindgen-gen-rust",
@@ -7208,68 +7473,56 @@ 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 = "7.0.0"
 dependencies = [
  "anyhow",
- "futures 0.3.30",
+ "fs_extra",
+ "futures",
  "serde",
  "tempfile",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 2.0.18",
+ "tokio",
  "virtual-fs",
  "wasmer",
  "wasmer-types",
  "wasmer-wasix",
- "wast 38.0.1",
+ "wast",
 ]
 
 [[package]]
 name = "wasmer-workspace"
-version = "4.3.7"
+version = "7.0.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",
+ "itertools 0.14.0",
+ "reqwest",
+ "rustc_version 0.4.1",
  "serial_test",
  "tempfile",
  "test-generator",
  "test-log",
- "tokio 1.38.1",
+ "tokio",
  "tracing",
  "tracing-subscriber",
  "ureq",
- "wasi-test-generator",
  "wasmer",
  "wasmer-cache",
  "wasmer-compiler",
  "wasmer-compiler-cranelift",
  "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
- "wasmer-emscripten",
  "wasmer-middlewares",
  "wasmer-types",
  "wasmer-wasix",
@@ -7277,96 +7530,132 @@ dependencies = [
 ]
 
 [[package]]
-name = "wasmparser"
-version = "0.95.0"
+name = "wasmi"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75c97bf74a48796b57fdfe35c00a9fe05410f0f1f8ccfe38591e382a0060a6fd"
+dependencies = [
+ "spin",
+ "wasmi_collections",
+ "wasmi_core",
+ "wasmi_ir",
+ "wasmparser 0.228.0",
+]
+
+[[package]]
+name = "wasmi_c_api_impl"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "141e4352c2c33345cdb7b8f40dbe6d1812c8075e1da6be878aa712cf9c22ca86"
+dependencies = [
+ "wasmi",
+ "wasmi_c_api_macros",
+]
+
+[[package]]
+name = "wasmi_c_api_macros"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0179887d55ff19d7ff67e4394da08365b3726cabe397e64004614ef4b8e58b20"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "wasmi_collections"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc03d171a00367f89bfb376fe952bb67e337a4992911948c22e1093730a4e718"
+
+[[package]]
+name = "wasmi_core"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ea896273ea99b15132414be1da01ab0d8836415083298ecaffbe308eaac87a"
+checksum = "9f2f829ada3e3fc5d723cd80feb7bbb1ba358ce3a9b069477b3c58c85f892c71"
 dependencies = [
- "indexmap 1.9.3",
- "url",
+ "libm",
 ]
 
 [[package]]
-name = "wasmparser"
-version = "0.121.2"
+name = "wasmi_ir"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
+checksum = "a28c3e221277780790bd0abd5c5da440dd39989cd8fa98330a4820d398a7af66"
 dependencies = [
- "bitflags 2.6.0",
- "indexmap 2.2.6",
- "semver 1.0.23",
+ "wasmi_core",
 ]
 
 [[package]]
-name = "wasmprinter"
-version = "0.2.80"
+name = "wasmparser"
+version = "0.228.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60e73986a6b7fdfedb7c5bf9e7eb71135486507c8fbc4c0c42cffcb6532988b7"
+checksum = "4abf1132c1fdf747d56bbc1bb52152400c70f336870f968b85e89ea422198ae3"
 dependencies = [
- "anyhow",
- "wasmparser 0.121.2",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
-name = "wast"
-version = "24.0.0"
+name = "wasmparser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff1e3bd3ad0b2ee7784add89c30dc96b89a54b43e5d6d95d774eda1863b3500"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "leb128",
+ "bitflags 2.10.0",
+ "indexmap",
+ "semver 1.0.27",
 ]
 
 [[package]]
-name = "wast"
-version = "38.0.1"
+name = "wasmprinter"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271"
+checksum = "09390d7b2bd7b938e563e4bff10aa345ef2e27a3bc99135697514ef54495e68f"
 dependencies = [
- "leb128",
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "wast"
-version = "64.0.0"
+name = "wasmtime-internal-math"
+version = "41.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a259b226fd6910225aa7baeba82f9d9933b6d00f2ce1b49b80fa4214328237cc"
+checksum = "d61fe7cfca53d0ce01dc480ce1db93ad48b6fa1f354d8ff0680ac6a76ef354a3"
 dependencies = [
- "leb128",
- "memchr",
- "unicode-width",
- "wasm-encoder 0.32.0",
+ "libm",
 ]
 
 [[package]]
-name = "wat"
-version = "1.0.71"
+name = "wast"
+version = "244.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53253d920ab413fca1c7dc2161d601c79b4fdf631d0ba51dd4343bf9b556c3f6"
+checksum = "b2e7b9f9e23311275920e3d6b56d64137c160cf8af4f84a7283b36cfecbf4acb"
 dependencies = [
- "wast 64.0.0",
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder 0.244.0",
 ]
 
 [[package]]
-name = "wcgi"
-version = "0.1.2"
+name = "wat"
+version = "1.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ca8f334eec3a8197bd25a612c74f415b8691d219ee11f1acd20f15a3e2bf77"
+checksum = "bbf35b87ed352f9ab6cd0732abde5a67dd6153dfd02c493e61459218b19456fa"
 dependencies = [
- "http 0.2.12",
- "http-serde 1.1.3",
- "serde",
- "serde_json",
- "url",
+ "wast",
 ]
 
 [[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 +7663,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.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfc134be64da186b33675e0154827ba8eb4eb30579c1142cebec88607cd2cf6"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
 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 +7695,75 @@ 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",
+ "bytes",
+ "cfg-if",
  "ciborium",
  "document-features",
- "flate2",
  "ignore",
- "indexmap 1.9.3",
+ "indexmap",
  "leb128",
  "lexical-sort",
  "libc",
  "once_cell",
  "path-clean",
- "rand",
- "semver 1.0.23",
+ "rand 0.8.5",
  "serde",
  "serde_json",
- "sha2",
+ "sha2 0.10.9",
  "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.5",
 ]
 
 [[package]]
-name = "weezl"
-version = "0.1.8"
+name = "webpki-roots"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+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.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
+[[package]]
+name = "which"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d"
+dependencies = [
+ "env_home",
+ "rustix",
+ "winsafe",
+]
 
 [[package]]
 name = "winapi"
@@ -7485,12 +7775,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 +7783,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,33 +7798,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 = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 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.114",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.48.0"
+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 = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-targets 0.48.5",
+ "windows-link",
 ]
 
 [[package]]
@@ -7562,18 +7874,21 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.48.5"
+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 = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
+ "windows-link",
 ]
 
 [[package]]
@@ -7585,7 +7900,7 @@ 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",
@@ -7593,10 +7908,21 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
+name = "windows-targets"
+version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+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"
@@ -7605,16 +7931,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -7623,22 +7943,22 @@ 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"
-version = "0.48.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.6"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
 
 [[package]]
 name = "windows_i686_gnullvm"
@@ -7647,16 +7967,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
+name = "windows_i686_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -7665,16 +7979,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
+name = "windows_i686_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -7683,10 +7991,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
+name = "windows_x86_64_gnu"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -7695,16 +8003,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -7713,83 +8015,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.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "557404e450152cd6795bb558bca69e43c585055f4606e3bcae5894fc6dac9ba0"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 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.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
-dependencies = [
- "winapi 0.2.8",
- "winapi-build",
-]
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 
 [[package]]
-name = "wyz"
-version = "0.5.1"
+name = "writeable"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
 [[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",
 ]
 
 [[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,59 +8087,171 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
-version = "0.7.35"
+version = "0.8.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+checksum = "fdea86ddd5568519879b8187e1cf04e24fce28f7fe046ceecbce472ff19a2572"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.35"
+version = "0.8.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+checksum = "0c15e1b46eff7c6c91195752e0eeed8ef040e391cdece7c25376957d5f15df22"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.114",
+]
+
+[[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.114",
+ "synstructure",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.8.1"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
 
 [[package]]
 name = "zip"
-version = "2.1.5"
+version = "7.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b895748a3ebcb69b9d38dcfdf21760859a4b0d0b0015277640c2ef4c69640e6f"
+checksum = "c42e33efc22a0650c311c2ef19115ce232583abbe80850bc8b66509ebef02de0"
 dependencies = [
- "arbitrary",
  "crc32fast",
- "crossbeam-utils 0.8.20",
- "displaydoc",
  "flate2",
- "indexmap 2.2.6",
+ "indexmap",
  "memchr",
- "thiserror",
+ "typed-path",
  "zopfli",
 ]
 
+[[package]]
+name = "zlib-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3"
+
+[[package]]
+name = "zmij"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439"
+
 [[package]]
 name = "zopfli"
-version = "0.8.1"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5019f391bac5cf252e93bbcc53d039ffd62c7bfb7c150414d61369afe57e946"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
 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..8291816be5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,151 +12,374 @@ 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 = "=7.0.0", path = "lib/api", default-features = false }
+wasmer-cache = { version = "=7.0.0", path = "lib/cache", optional = true }
+wasmer-compiler = { version = "=7.0.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 = "=7.0.0", path = "lib/compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { version = "=7.0.0", path = "lib/compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { version = "=7.0.0", path = "lib/compiler-singlepass", optional = true }
+wasmer-middlewares = { version = "=7.0.0", path = "lib/middlewares", optional = true }
+wasmer-types = { version = "=7.0.0", path = "lib/types" }
+wasmer-wast = { version = "=7.0.0", path = "tests/lib/wast", 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 }
 
 # Third party dependencies
-cfg-if = "1.0"
-tokio = { version = "1", features = [
-    "rt",
-    "rt-multi-thread",
-    "macros",
+cfg-if.workspace = true
+crossbeam-queue.workspace = true
+tokio = { workspace = true, 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",
+	"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",
 ]
+exclude = ["./lib/cli/tests/packages/axum"]
 resolver = "2"
 
 [workspace.package]
 authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
-edition = "2021"
+edition = "2024"
 homepage = "https://wasmer.io/"
 license = "MIT"
 repository = "https://github.com/wasmerio/wasmer"
-rust-version = "1.74"
-version = "4.3.7"
+rust-version = "1.91"
+version = "7.0.0"
 
 [workspace.dependencies]
 # Repo-local crates
+wasmer-package = { version = "0.700.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
-dashmap = "6.0.1"
-http = "1.0.0"
-hyper = "1"
-reqwest = { version = "0.12.0", default-features = false }
+anyhow = "1.0"
+assert-panic = "1.0.1"
+assert_cmd = "2.1.1"
+async-trait = "0.1.68"
+async-tungstenite = "0.32.1"
+axum = { version = "=0.6.9", default-features = false }
+backtrace = "0.3"
+base64 = "0.22.1"
+bincode = "2.0.1"
+bindgen = { version = "0.72.1", default-features = false }
+bitflags = "2.10.0"
+blake3 = "1.0"
+build-deps = "0.1.4"
+bus = "2.4.1"
+bytecheck = { version = "0.8.2" }
+byteorder = "1.3"
+bytes = "1"
+bytesize = "2.3.1"
+cargo_metadata = "0.23.1"
+cbindgen = { version = "0.29", default-features = false }
+cc = "1.2.47"
+cfg-if = "1.0"
+chrono = { version = "^0.4.38", default-features = false }
+ciborium = "0.2.2"
+clap = { version = "4.5.53", default-features = false }
+clap_builder = { version = "4.5.53" }
+clap_complete = "4.5.61"
+clap_derive = { version = "4.5.49" }
+clap_lex = { version = "0.7.6" }
+clap_mangen = "0.2.31"
+cmake = "0.1.50"
+colored = "3.0.0"
+comfy-table = "7.2.1"
+compiletest_rs = "0.11.2"
+console = "0.16.1"
+console-subscriber = "0.5.0"
+cooked-waker = "^5"
+corosensei = "0.3.0"
+cranelift-codegen = { version = "=0.128.0", default-features = false }
+cranelift-entity = { version = "=0.128.0", default-features = false }
+cranelift-frontend = { version = "=0.128.0", default-features = false }
+criterion = { version = "0.8.1", default-features = false }
+crossbeam-channel = "0.5.15"
+crossbeam-queue = "0.3.8"
+cynic = { version = "3.7.2", default-features = false }
+dashmap = "6.1.0"
+derive_builder = "0.20.2"
+derive_more = { version = "2.0.1", features = ["debug", "display"] }
+dialoguer = "0.12.0"
+dirs = "6.0.0"
+dotenvy = "0.15.7"
+dunce = "1.0.4"
+dynasm = "4.0.0"
+dynasmrt = "4.0.0"
+enum-iterator = "2.3.0"
 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"] }
-memmap2 = { version = "0.6.2" }
-toml = {version = "0.5.9", features = ["preserve_order"]}
+env_logger = { version = "0.11.5", default-features = false }
+field-offset = "0.3.3"
+filetime = "0.2.18"
+flate2 = "1.0.34"
+zstd = "0.13.2"
+fnv = "1.0.3"
+fs_extra = { version = "1.3.0" }
+futures = "0.3.30"
+futures-util = { version = "0.3.31" }
+getrandom = "0.2"
+gimli = { version = "0.32.3" }
+git-version = "0.3.9"
+glob = "0.3"
+graphql-ws-client = "0.12.0"
+gumdrop = "0.8"
+harsh = "0.2.2"
+hashbrown = "0.16.1"
+heapless = "0.9.2"
+hex = "0.4"
+hexdump = "0.1.2"
+http = "1.4.0"
+http-body-util = "0.1.1"
+humantime = "2.1.0"
+hyper = "1.8.1"
+hyper-tungstenite = "0.19"
+hyper-util = "0.1.5"
+ignore = "0.4"
+indicatif = "0.18.3"
 indexmap = "2"
-serde_yaml = "0.9.34"
-libc = { version = "^0.2", default-features = false }
+inline-c = "0.1.7"
+inkwell = { version = "0.8.0", default-features = false }
+insta = "1.45.0"
+interfaces = "0.0.9"
+ipnet = "2.10.1"
+iprange = "0.6.7"
+itertools = "0.14"
+js-sys = "0.3.77"
+leb128 = "0.2"
+libc = { version = "0.2.178", default-features = false }
+libfuzzer-sys = "0.4.0"
+libunwind = "1.3.3"
+linked_hash_set = "0.1.6"
+log = "0.4.22"
+lz4_flex = "0.12.0"
+lzma-rs = "0.3.0"
+mac_address = "1.1.5"
+mach2 = "0.6.0"
+macho-unwind-info = "0.5.0"
+md5 = "0.8.0"
+memmap2 = { version = "0.9.9" }
+memoffset = "0.9.1"
+merge-streams = "0.1.2"
+mio = "1"
+more-asserts = "0.3.1"
+normpath = "1.5.0"
+num_enum = "0.7.3"
+object = "0.38.0"
+once_cell = "1.17.1"
+opener = "0.8.3"
+parking = "2.2"
+parking_lot = "0.12.1"
+paste = "1.0.15"
+path-clean = "1.0.1"
+pathdiff = "0.2.1"
+petgraph = "0.8.3"
+phf = "0.13.1"
+pin-project = "1.0.12"
+pin-project-lite = "0.2.10"
+pin-utils = "0.1.0"
+predicates = "3.1.3"
+pretty_assertions = "1.4.0"
+proc-macro-error2 = "2.0.1"
+proc-macro2 = "1"
+quote = "1.0.20"
+rand = "0.9.2"
+rangemap = "1.7.1"
+rayon = "1.7.0"
+regex = "1.11"
+region = "3.0"
+replace_with = "0.1.7"
+reqwest = { version = "0.12.0", default-features = false }
+rkyv = { version = "0.8.13", features = ["indexmap-2", "bytes-1"] }
+rustc-demangle = "0.1"
+rustc_version = "0.4"
+rusty_jsc = "0.1.0"
+rusty_pool = "0.7.0"
+rustversion = "1.0"
+saffron = "0.1.0"
+schemars = "1.1.0"
+scopeguard = "1.1.0"
+self_cell = "1.0"
+semver = "1.0"
+serde = { version = "1", default-features = false }
+serde-wasm-bindgen = "0.6.5"
+serde_bytes = { version = "0.11" }
+serde_derive = "^1"
+serde_json = { version = "1" }
+serde_path_to_error = "0.1.14"
+serde_yaml = { version = "0.9.34" }
+serial_test = { version = "3.2.0", default-features = false }
+sha2 = "0.11.0-rc.3"
+slab = "0.4"
+smallvec = "1.6"
+smoltcp = { version = "0.12.0", default-features = false }
+socket2 = { version = "0.6.1", features = ["all"] }
+syn = { version = "2", default-features = false }
+tar = "0.4.40"
+target-lexicon = { version = "0.13.3", default-features = false }
+tempfile = "3.6.0"
+terminal_size = "0.4.3"
+termios = "0.3"
+test-log = { version = "0.2", default-features = false }
+thiserror = "2.0.17"
+time = { version = "0.3.44", default-features = false }
+# MIO 1.0 starts at tokio version 1.39, hence the minimum requirement.
+tokio = { version = "1.39.0", default-features = false }
+tokio-serde = "0.9"
+tokio-stream = "0.1"
+tokio-tungstenite = { version = "0.28.0" }
+tokio-util = "0.7.8"
+toml = { version = "0.9.8", features = ["preserve_order"] }
+tower = "0.5.2"
+tower-http = "0.6.7"
+tracing = { version = "0.1", default-features = false }
+tracing-subscriber = { version = "0.3", default-features = false }
+tracing-test = { version = "0.2" }
+tracing-wasm = "0.2"
+trybuild = "1.0.11"
+typetag = "0.2.21"
+uniffi = "0.30.0"
+unix_mode = "0.1.3"
+ureq = "3.1.4"
+url = "2.5"
+urlencoding = "^2"
+uuid = { version = "1", default-features = false }
+wai-bindgen-gen-core = { version = "0.2.1", default-features = false }
+wai-bindgen-gen-rust = { version = "0.2.1", default-features = false }
+wai-bindgen-gen-rust-wasm = { version = "0.2.1", default-features = false }
+wai-bindgen-rust = { version = "0.2.1", default-features = false }
+wai-bindgen-wasmer-impl = "0.2.2"
+wai-parser = "0.2.1"
+waker-fn = "1.1"
+walkdir = "2.3.2"
+wasm-bindgen = "0.2.100"
+wasm-bindgen-futures = "0.4.37"
+wasm-bindgen-test = "0.3.0"
+wasm-coredump-builder = "0.2.2"
+wasm-encoder = { version = "0.244.0", default-features = false, features = [
+	"std",
+] }
+wasm-smith = "0.244.0"
+wasmi_c_api_impl = "1.0.4"
+wasmparser = { version = "0.244.0", default-features = false, features = [
+	"validate",
+	"features",
+	"simd",
+] }
+wasmprinter = "0.244.0"
+wasmer-inline-c = "0.1.1"
+wast = "244.0.0"
+wat = "1.243.0"
+wcgi = "0.3.0"
+wcgi-host = "0.3.0"
+web-sys = "0.3.64"
+web-time = "1.1"
+weezl = "^0.1"
+which = "8.0.0"
+windows-sys = { version = "0.61.2", default-features = false }
+xxhash-rust = { version = "0.8.10", default-features = false }
+xz = "0.1.0"
+zip = { version = "7.2.0", default-features = false }
 
 [build-dependencies]
 test-generator = { path = "tests/lib/test-generator" }
-build-deps = "0.1.4"
-anyhow = "1.0"
-glob = "0.3"
-rustc_version = "0.4"
+build-deps.workspace = true
+anyhow.workspace = true
+glob.workspace = true
+rustc_version.workspace = true
 
 [dev-dependencies]
-wasmer = { version = "=4.3.7", path = "lib/api", features = [
-    "compiler",
-    "singlepass",
-    "sys",
+wasmer = { version = "=7.0.0", path = "lib/api", features = [
+	"compiler",
+	"singlepass",
+	"sys",
 ] }
-anyhow = "1.0"
-criterion = { version = "0.5", default-features = false }
-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 }
+anyhow.workspace = true
+clap.workspace = true
+clap_builder.workspace = true
+clap_derive.workspace = true
+clap_lex.workspace = true
+criterion = { workspace = true, features = ["csv_output"] }
+serial_test = { workspace = true, default-features = false }
 compiler-test-derive = { path = "tests/lib/compiler-test-derive" }
-tempfile = "3.6.0"
-ureq = "2.6"
+tempfile.workspace = true
+ureq.workspace = true
 # For logging tests using the `RUST_LOG=debug` when testing
-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",
+test-log = { workspace = true, default-features = false, features = ["trace"] }
+tracing = { workspace = true, default-features = false, features = ["log"] }
+tracing-subscriber = { workspace = true, default-features = false, features = [
+	"env-filter",
+	"fmt",
 ] }
+reqwest = { workspace = true, features = ["blocking", "rustls-tls"] }
+itertools.workspace = true
 
 [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"]
@@ -167,6 +390,7 @@ 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"]
+experimental-async = ["wasmer/experimental-async"]
 
 # Testing features
 test-singlepass = ["singlepass"]
@@ -204,6 +428,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 +503,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 +526,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 +548,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"
@@ -351,3 +597,8 @@ required-features = ["cranelift"]
 name = "http-dynamic-size"
 path = "examples/http_dynamic_size.rs"
 required-features = ["cranelift"]
+
+[[example]]
+name = "throw-exception"
+path = "examples/throw_exception.rs"
+required-features = ["llvm"]
diff --git a/Makefile b/Makefile
index 97dc61d550..997b95aa97 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,32 +151,33 @@ 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-21 2>/dev/null))
+	LLVM_VERSION := $(shell llvm-config-21 --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_211_PREFIX, or llvm_sys will not build in the case
+	export LLVM_SYS_211_PREFIX = $(shell llvm-config-21 --prefix)
 else ifneq (, $(shell which llvm-config 2>/dev/null))
 	LLVM_VERSION := $(shell llvm-config --version)
-	ifneq (, $(findstring 15,$(LLVM_VERSION)))
+	ifneq (, $(findstring 21,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
-	else ifneq (, $(findstring 14,$(LLVM_VERSION)))
+		export LLVM_SYS_211_PREFIX = $(shell llvm-config --prefix)
+	else ifneq (, $(findstring 21,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
+		export LLVM_SYS_211_PREFIX = $(shell llvm-config --prefix)
 	endif
 endif
 
 # If findstring is not empty, then it have found the value
 
-exclude_tests := --exclude wasmer-c-api --exclude wasmer-cli --exclude wasmer-compiler-cli
+exclude_tests := --exclude wasmer-c-api --exclude wasmer-cli
 # 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
@@ -305,8 +371,8 @@ HOST_TARGET=$(shell rustc -Vv | grep 'host: ' | cut -d':' -f2 | tr -d ' ')
 
 TARGET_DIR ?= target/release
 
-ifneq (, $(TARGET))
-	TARGET_DIR ?= target/$(TARGET)/release
+ifneq (, $(CARGO_TARGET))
+	TARGET_DIR = target/$(CARGO_TARGET)/release
 endif
 
 $(info -----------)
@@ -314,17 +380,17 @@ $(info $(bold)$(green)INFORMATION$(reset))
 $(info -----------)
 $(info )
 $(info Host Target: `$(bold)$(green)$(HOST_TARGET)$(reset)`.)
-ifneq (, $(TARGET))
+ifneq (, $(CARGO_TARGET))
 	# We use spaces instead of tabs to indent `$(info)`
 	# otherwise it's considered as a command outside a
 	# target and it will fail.
-        $(info Build Target: $(bold)$(green)$(TARGET)$(reset) $(yellow)($(TARGET_DIR))$(reset))
+    $(info Build Target: $(bold)$(green)$(CARGO_TARGET)$(reset) $(yellow)($(TARGET_DIR))$(reset))
 endif
 ifneq (, $(LIBC))
 	# We use spaces instead of tabs to indent `$(info)`
 	# otherwise it's considered as a command outside a
 	# target and it will fail.
-        $(info C standard library: $(bold)$(green)$(LIBC)$(reset))
+    $(info C standard library: $(bold)$(green)$(LIBC)$(reset))
 endif
 $(info Enabled Compilers: $(bold)$(green)$(subst $(space),$(reset)$(comma)$(space)$(bold)$(green),$(compilers))$(reset).)
 $(info Testing the following compilers & engines:)
@@ -335,7 +401,7 @@ $(info   * Compilers: `$(bold)$(green)${compiler_features}$(reset)`.)
 $(info Rust version: $(bold)$(green)$(shell rustc --version)$(reset).)
 $(info NodeJS version: $(bold)$(green)$(shell node --version)$(reset).)
 ifeq ($(ENABLE_LLVM), 1)
-        $(info LLVM version: $(bold)$(green)${LLVM_VERSION}$(reset).)
+    $(info LLVM version: $(bold)$(green)${LLVM_VERSION}$(reset).)
 endif
 $(info )
 $(info )
@@ -371,33 +437,43 @@ endif
 # install will go through.
 all: build-wasmer build-capi build-capi-headless
 
-check: check-wasmer check-wasmer-wasm check-capi
+check: check-wasmer check-api-no-async check-capi
 
 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
+check-api-no-async:
+	$(CARGO_BINARY) check $(CARGO_TARGET_FLAG) --manifest-path lib/api/Cargo.toml $(compiler_features) --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
+	RUSTFLAGS="--cfg tokio_unstable" \
+		$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --features tokio-subscriber --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
 
 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
-
 # For best results ensure the release profile looks like the following
 # in Cargo.toml:
 # [profile.release]
@@ -412,7 +488,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,singlepass --bin wasmer-headless
 ifeq ($(IS_DARWIN), 1)
 	strip target/$(HOST_TARGET)/release/wasmer-headless
 else ifeq ($(IS_WINDOWS), 1)
@@ -422,7 +498,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) --features wasmer/experimental-async --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 +530,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 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 doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --features "$$features" --locked || exit 1; \
 		fi; \
 	done
 
@@ -481,7 +562,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 +588,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,wasmer-api/cranelift --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,wasmer-api/cranelift --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
 
 #####
 #
@@ -532,21 +625,21 @@ build-capi-headless-ios:
 #
 #####
 
-# test compilers
+# test compilers (intentionally not using nextest as it runs tests in separate processes)
 test-stage-0-wast:
-	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked
 
 # 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) --features experimental-async --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) --features experimental-async --locked
 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:
 	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/compiler-singlepass/Cargo.toml --release --no-default-features --features=std --locked
 test-stage-4-wasmer-cli:
-	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/virtual-fs/Cargo.toml --release --locked
-	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --release --locked
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/virtual-fs/Cargo.toml --release --locked && \
+$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --release --locked
 
 # test examples
 test-stage-5-test-examples:
@@ -555,8 +648,8 @@ test-stage-6-test-examples-release:
 	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release $(compiler_features) --features wasi --examples --locked
 
 test-stage-7-capi-integration-tests:
-	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-c-api-test-runner --locked
-	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-capi-examples-runner --locked
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-c-api-test-runner --locked && \
+$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-capi-examples-runner --locked
 
 test: test-compilers test-packages test-examples
 
@@ -566,6 +659,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.
@@ -576,6 +685,9 @@ test-js: test-js-api test-js-wasi
 test-js-api:
 	cd lib/api && wasm-pack test --node -- --no-default-features --features js-default,wat
 
+lint-js:
+	cargo clippy --target wasm32-unknown-unknown --manifest-path lib/api/Cargo.toml --no-default-features --features "js-default" --locked -- -D clippy::all
+
 test-js-wasi:
 	cd lib/wasix && wasm-pack test --node -- --no-default-features --features test-js,wasmer/js,wasmer/std
 
@@ -605,16 +717,27 @@ test-llvm: $(foreach llvm_engine,$(filter llvm-%,$(compilers_engines)),test-$(ll
 # same as test-capi, but without the build-capi step first
 test-capi-ci: $(foreach compiler_engine,$(capi_compilers_engines),test-capi-crate-$(compiler_engine) test-capi-integration-$(compiler_engine))
 
+# Run clippy for the C API crate across the CI matrix.
+lint-capi-ci: $(foreach compiler_engine,$(capi_compilers_engines),lint-capi-crate-$(compiler_engine))
+
 # This test requires building the capi with all the available
 # 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-%:
 	WASMER_CAPI_CONFIG=$(shell echo $@ | sed -e s/test-capi-crate-//) $(CARGO_BINARY) test $(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 -- --nocapture
 
+lint-capi-crate-%:
+	WASMER_CAPI_CONFIG=$(shell echo $@ | sed -e s/lint-capi-crate-//) RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) clippy $(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 -- -D clippy::all
+
 test-capi-integration-%:
 	# note: you need to do make build-capi and make package-capi first!
 	# Test the Wasmer C API tests for C
@@ -638,14 +761,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
+	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,18 +1056,35 @@ 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 --examples --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
 
+lint-wasmi:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) clippy $(CARGO_TARGET_FLAG) --package=wasmer --no-default-features --features="wasmi-default" --locked -- -D clippy::all
+
+lint-wamr:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) clippy $(CARGO_TARGET_FLAG) --package=wasmer --no-default-features --features="wamr-default" --locked -- -D clippy::all
+
+lint-v8:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) clippy $(CARGO_TARGET_FLAG) --package=wasmer --no-default-features --features="v8-default" --locked -- -D clippy::all
+
+lint-jsc:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) clippy $(CARGO_TARGET_FLAG) --package=wasmer --no-default-features --features="jsc-default,wat" --locked -- -D clippy::all
+
+lint-package-crate:
+	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path lib/package/Cargo.toml --locked -- -D clippy::all
+
 lint-formatting:
 	cargo fmt --all -- --check
 	cargo fmt --manifest-path fuzz/Cargo.toml -- --check
 
 lint: lint-formatting lint-packages
 
+lint-all: lint-formatting lint-packages lint-wasmi lint-wamr lint-v8 lint-jsc lint-capi-ci lint-package-crate
+
 install-local: package
 	tar -C ~/.wasmer -zxvf wasmer.tar.gz
 
@@ -948,3 +1097,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..e917572ebc 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):
 
@@ -136,6 +142,7 @@ languages** with the Wasmer SDK:
 | ![Ruby logo]     | [**Ruby**][Ruby integration]         | [`wasmer` Ruby Gem]                   | [Learn][ruby docs]     |
 | ![Java logo]     | [**Java**][Java integration]         | [`wasmer/wasmer-jni` Bintray package] | [Learn][java docs]     |
 | ![R logo]        | [**R**][R integration]               | _no published package_                | [Learn][r docs]        |
+| ![R logo]        | [**R**][R integration_1]               | _no published package_              | [Learn][r docs_1]      |
 | ![Postgres logo] | [**Postgres**][Postgres integration] | _no published package_                | [Learn][postgres docs] |
 | ![Swift logo]    | [**Swift**][Swift integration]       | _no published package_                |                        |
 | ![Dart logo]     | [**Dart**][Dart integration]         | [`wasm` pub package]                  |                        |
@@ -180,7 +187,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
@@ -196,6 +203,8 @@ languages** with the Wasmer SDK:
 [r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
 [r integration]: https://github.com/dirkschumacher/wasmr
 [r docs]: https://github.com/dirkschumacher/wasmr#example
+[r integration_1]: https://sounkou-bioinfo.r-universe.dev/wasmer
+[r docs_1]: https://sounkou-bioinfo.r-universe.dev/wasmer/doc/manual.html
 [postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
 [postgres integration]: https://github.com/wasmerio/wasmer-postgres
 [postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
@@ -238,7 +247,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
 
@@ -257,6 +266,7 @@ Wasmer has an amazing community of developers and contributors. Welcome, please
 
 - [Wasmer Community Discord](https://discord.gg/rWkMNStrEW)
 - [Wasmer on Twitter](https://twitter.com/wasmerio)
+- [Wasmer on LinkedIn](https://www.linkedin.com/company/wasmerio)
 
 --------
 
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..f1642691d4
--- /dev/null
+++ b/benches/compile.rs
@@ -0,0 +1,150 @@
+use criterion::{
+    BenchmarkGroup, Criterion, criterion_group, criterion_main, measurement::WallTime,
+};
+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..789a2fe8ad
--- /dev/null
+++ b/benches/deserialize_modules.rs
@@ -0,0 +1,51 @@
+use criterion::{Criterion, criterion_group, criterion_main};
+
+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..b32fea30ba 100644
--- a/benches/import_functions.rs
+++ b/benches/import_functions.rs
@@ -1,4 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use criterion::{Criterion, criterion_group, criterion_main};
 
 use wasmer::*;
 
@@ -33,26 +35,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..a4ff0a3462
--- /dev/null
+++ b/benches/run.rs
@@ -0,0 +1,82 @@
+use criterion::{Criterion, criterion_group, criterion_main};
+use wasmer::*;
+
+static BENCHMARKS_ARTIFACTS_BASE_URL: &str = "https://pub-083d1a0568d446d1aa5b2e07bd16983b.r2.dev";
+
+#[allow(unreachable_code)]
+fn get_engine() -> Engine {
+    #[cfg(feature = "llvm")]
+    return wasmer_compiler_llvm::LLVM::new().into();
+
+    #[cfg(feature = "singlepass")]
+    return wasmer_compiler_singlepass::Singlepass::new().into();
+
+    #[cfg(feature = "cranelift")]
+    return wasmer_compiler_cranelift::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..082c130f60 100644
--- a/benches/static_and_dynamic_functions.rs
+++ b/benches/static_and_dynamic_functions.rs
@@ -1,4 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use criterion::{Criterion, criterion_group, criterion_main};
 
 use wasmer::*;
 
@@ -42,7 +44,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);
@@ -50,33 +52,31 @@ pub fn run_basic_static_function(store: &mut Store, compiler_name: &str, c: &mut
     });
 
     let dyn_f_many: &Function = instance.exports.get("add20").unwrap();
-    let f_many: TypedFunction<
-        (
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-        ),
-        i32,
-    > = dyn_f_many.typed(store).unwrap();
+    type TupleWithMany = (
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+        i32,
+    );
+    let f_many: TypedFunction<TupleWithMany, 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..07de79eaad 100644
--- a/build.rs
+++ b/build.rs
@@ -9,11 +9,27 @@ use std::fs;
 use std::path::PathBuf;
 use std::process::Command;
 use test_generator::{
-    test_directory, test_directory_module, wasi_processor, wast_processor, with_test_module,
-    Testsuite,
+    Testsuite, test_directory, test_directory_module, wasi_processor, wast_processor,
+    with_test_module,
 };
 
 fn main() -> anyhow::Result<()> {
+    println!(
+        "cargo:rustc-env=CFG_TARGET_OS={}",
+        std::env::var("CARGO_CFG_TARGET_OS")
+            .expect("CARGO_CFG_TARGET_OS must be provided by cargo")
+    );
+    println!(
+        "cargo:rustc-env=CFG_TARGET_ARCH={}",
+        std::env::var("CARGO_CFG_TARGET_ARCH")
+            .expect("CARGO_CFG_TARGET_ARCH must be provided by cargo")
+    );
+    println!(
+        "cargo:rustc-env=CFG_TARGET_ENV={}",
+        std::env::var("CARGO_CFG_TARGET_ENV")
+            .expect("CARGO_CFG_TARGET_ENV must be provided by cargo")
+    );
+
     // As rerun-if-changed doesn't support globs, we use another crate
     // to check changes in directories.
     build_deps::rerun_if_changed_paths("tests/wasi-wast/wasi/unstable/*")
@@ -22,6 +38,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 +59,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 +108,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..54b279f337 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,155 @@
 # 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" },
 
+	"RUSTSEC-2024-0436", # unmaintained 'paste' crate
+	"RUSTSEC-2025-0141", # unmaintained 'bincode' crate
 ]
 # 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",
-]
-# 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",
+	"MIT",
+	"Apache-2.0",
+	"Apache-2.0 WITH LLVM-exception",
+	"ISC",
+	"BSD-2-Clause",
+	"MPL-2.0",
+	"0BSD",
+	"CC0-1.0",
+	"BSD-3-Clause",
+	# BOOST source license
+	# NOTE: not to be confused with business source license!
+	"BSL-1.0",
+	"Unicode-3.0",
+	"CDLA-Permissive-2.0",
+	"Zlib",
+	"bzip2-1.0.6"
 ]
-# 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"
+crate = "wasmer-compiler-singlepass"
+expression = "BUSL-1.1"
 license-files = [
-  { path = "LICENSE.txt", hash = 0xa2180a97 }
+    { path = "LICENSE", hash = 0x11303e40 },
 ]
 
 [[licenses.clarify]]
-name = "ring"
-version = "*"
-expression = "MIT AND ISC AND OpenSSL"
+crate = "wasmer-compiler-llvm"
+expression = "BUSL-1.1"
 license-files = [
-    # Each entry is a crate relative path, and the (opaque) hash of its contents
-    { path = "LICENSE", hash = 0xbd0eed23 }
+    { path = "LICENSE", hash = 0x79b6d01b },
 ]
 
+# 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]]
+crate = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+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 +188,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 +253,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..0bae77e815 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:
 
@@ -603,3 +603,72 @@ used by default, but certain options use it (e.g., the optional closure compiler
 flag will run closure compiler from third_party/).
 
 ```
+
+### Zlib
+
+```text
+version 1.3.1, January 22nd, 2024
+
+  Copyright (C) 1995-2024 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+```
+
+### bzip2-1.0.6
+
+```text
+This program, "bzip2", the associated library "libbzip2", and all
+documentation, are copyright (C) 1996-2010 Julian R Seward.  All
+rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. The origin of this software must not be misrepresented; you must
+   not claim that you wrote the original software.  If you use this
+   software in a product, an acknowledgment in the product
+   documentation would be appreciated but is not required.
+
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
+
+4. The name of the author may not be used to endorse or promote
+   products derived from this software without specific prior written
+   permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Julian Seward, jseward@bzip.org
+bzip2/libbzip2 version 1.0.6 of 6 September 2010
+```
diff --git a/docs/BUILD.md b/docs/BUILD.md
index 09439213b8..e6694eaae3 100644
--- a/docs/BUILD.md
+++ b/docs/BUILD.md
@@ -2,9 +2,8 @@
 
 ## Installing Rustup
 
-Building Wasmer from source requires [Rust](https://rustup.rs/) **1.67+**.
-
-The easiest way to install Rust on your system is via Rustup. To get Rustup on Linux and macOS, you can run the following:
+Wasmer supports building with the latest **3** stable releases of Rust.
+The easiest way to install Rust on your system is via [Rustup](https://rustup.rs/). To get Rustup on Linux and macOS, you can run the following:
 
 ```bash
 curl https://sh.rustup.rs -sSf | sh
@@ -15,14 +14,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 21. To install it,
+refer to [LLVM's download
+page](https://github.com/llvm/llvm-project/releases/tag/llvmorg-21.1.6) 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 21. To install it on
+macOS, you can use [homebrew](https://brew.sh/): `brew install llvm@21`.
+
 ### 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 21.0](https://github.com/llvm/llvm-project/releases/download/llvmorg-21.1.6/LLVM-21.1.6-win64.exe)
 
 ## Building the Wasmer Runtime
 
@@ -35,41 +50,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 >=21.1.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 21.1.x
+  would be: `LLVM_SYS_211_PREFIX=/path/to/unpacked/llvm-21.1`
 
 And create a Wasmer release
 
@@ -82,6 +109,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 +155,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 +171,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 +180,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/dev/create-exe.md b/docs/dev/create-exe.md
index 293b0a20d6..54d6963b59 100644
--- a/docs/dev/create-exe.md
+++ b/docs/dev/create-exe.md
@@ -1,5 +1,10 @@
 # wasmer create-exe
 
+> [!Caution] 
+This feature has been disabled from wasmer-cli due to unresolved issues and insufficient support capabilities to fix them.
+We would like to re-enable this as soon as all the existing issues are resolved
+(feel free to create a PR if you would like to help us with this quest: #5422, #5954)
+
 ## Motivation and Goal
 
 The goal of create-exe is to create easily runnable executables on every
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..22c62d3346 100644
--- a/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
+++ b/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
@@ -1,12 +1,8 @@
 {
   "$schema": "https://json-schema.org/draft/2019-09/schema",
   "title": "AppConfigV1",
-  "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.",
+  "description": "User-facing app.yaml config file for apps.\n\nNOTE: only used by the backend; Edge itself does not use this format and\nrelies on the internal `AppVersionV1Spec` representation instead.",
   "type": "object",
-  "required": [
-    "name",
-    "package"
-  ],
   "properties": {
     "app_id": {
       "description": "App id assigned by the backend.\n\nThis will get populated once the app has been deployed.\n\nThis id is also used to map to the existing app during deployments.",
@@ -18,7 +14,7 @@
     "capabilities": {
       "anyOf": [
         {
-          "$ref": "#/definitions/AppConfigCapabilityMapV1"
+          "$ref": "#/$defs/AppConfigCapabilityMapV1"
         },
         {
           "type": "null"
@@ -43,7 +39,7 @@
       ]
     },
     "domains": {
-      "description": "Domains for the app.\n\nThis can include both provider-supplied alias domains and custom domains.",
+      "description": "Domains for the app.\n\nThis can include both provider-supplied\nalias domains and custom domains.",
       "type": [
         "array",
         "null"
@@ -65,14 +61,23 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/HealthCheckV1"
+        "$ref": "#/$defs/HealthCheckV1"
+      }
+    },
+    "jobs": {
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/$defs/Job"
       }
     },
     "locality": {
       "description": "Location-related configuration for the app.",
       "anyOf": [
         {
-          "$ref": "#/definitions/Locality"
+          "$ref": "#/$defs/Locality"
         },
         {
           "type": "null"
@@ -81,7 +86,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.",
@@ -92,12 +100,12 @@
     },
     "package": {
       "description": "The package to execute.",
-      "$ref": "#/definitions/PackageSource"
+      "$ref": "#/$defs/PackageSource"
     },
     "redirect": {
       "anyOf": [
         {
-          "$ref": "#/definitions/Redirect"
+          "$ref": "#/$defs/Redirect"
         },
         {
           "type": "null"
@@ -107,7 +115,7 @@
     "scaling": {
       "anyOf": [
         {
-          "$ref": "#/definitions/AppScalingConfigV1"
+          "$ref": "#/$defs/AppScalingConfigV1"
         },
         {
           "type": "null"
@@ -120,7 +128,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/AppScheduledTask"
+        "$ref": "#/$defs/AppScheduledTask"
       }
     },
     "volumes": {
@@ -129,41 +137,60 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/AppVolume"
+        "$ref": "#/$defs/AppVolume"
       }
     }
   },
   "additionalProperties": true,
-  "definitions": {
+  "required": [
+    "package"
+  ],
+  "$defs": {
     "AppConfigCapabilityInstaBootV1": {
-      "description": "Enables accelerated instance boot times with startup snapshots.\n\nHow it works: The Edge runtime will create a pre-initialized snapshot of apps that is ready to serve requests Your app will then restore from the generated snapshot, which has the potential to significantly speed up cold starts.\n\nTo drive the initialization, multiple http requests can be specified. All the specified requests will be sent to the app before the snapshot is created, allowing the app to pre-load files, pre initialize caches, ...",
+      "description": "Enables accelerated instance boot times with startup snapshots.\n\nHow it works:\nThe Edge runtime will create a pre-initialized snapshot of apps that is\nready to serve requests\nYour app will then restore from the generated snapshot, which has the\npotential to significantly speed up cold starts.\n\nTo drive the initialization, multiple http requests can be specified.\nAll the specified requests will be sent to the app before the snapshot is\ncreated, allowing the app to pre-load files, pre initialize caches, ...",
       "type": "object",
       "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"
+          "description": "Maximum age of snapshots.\n\nFormat: 5m, 1h, 2d, ...\n\nAfter the specified time new snapshots will be created, and the old\nones discarded.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
+        "mode": {
+          "description": "The method to use to generate the instaboot snapshot for the instance.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/InstabootSnapshotModeV1"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
+        },
         "requests": {
-          "description": "HTTP requests to perform during startup snapshot creation. Apps can perform all the appropriate warmup logic in these requests.\n\nNOTE: if no requests are configured, then a single HTTP request to '/' will be performed instead.",
+          "description": "HTTP requests to perform during startup snapshot creation.\nApps can perform all the appropriate warmup logic in these requests.\n\nNOTE: if no requests are configured, then a single HTTP\nrequest to '/' will be performed instead.",
           "type": "array",
           "items": {
-            "$ref": "#/definitions/HttpRequest"
+            "$ref": "#/$defs/HttpRequest"
           }
         }
       }
     },
     "AppConfigCapabilityMapV1": {
-      "description": "Restricted version of [`super::CapabilityMapV1`], with only a select subset of settings.",
+      "description": "Restricted version of the internal `CapabilityMapV1`, with only a select\nsubset of settings.",
       "type": "object",
       "properties": {
         "instaboot": {
           "description": "Enables app bootstrapping with startup snapshots.",
           "anyOf": [
             {
-              "$ref": "#/definitions/AppConfigCapabilityInstaBootV1"
+              "$ref": "#/$defs/AppConfigCapabilityInstaBootV1"
             },
             {
               "type": "null"
@@ -174,7 +201,28 @@
           "description": "Instance memory settings.",
           "anyOf": [
             {
-              "$ref": "#/definitions/AppConfigCapabilityMemoryV1"
+              "$ref": "#/$defs/AppConfigCapabilityMemoryV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "runtime": {
+          "description": "Runtime settings.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/AppConfigCapabilityRuntimeV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "ssh": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CapabilitySshServerV1"
             },
             {
               "type": "null"
@@ -185,7 +233,7 @@
       "additionalProperties": true
     },
     "AppConfigCapabilityMemoryV1": {
-      "description": "Memory capability settings.\n\nNOTE: this is kept separate from the [`super::CapabilityMemoryV1`] struct to have separation between the high-level app.yaml and the more internal App entity.",
+      "description": "Memory capability settings.\n\nNOTE: this is kept separate from the internal `CapabilityMemoryV1` struct\nto keep the high-level app.yaml distinct from the internal App entity.",
       "type": "object",
       "properties": {
         "limit": {
@@ -197,13 +245,33 @@
         }
       }
     },
+    "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": {
         "mode": {
           "anyOf": [
             {
-              "$ref": "#/definitions/AppScalingModeV1"
+              "$ref": "#/$defs/AppScalingModeV1"
             },
             {
               "type": "null"
@@ -220,21 +288,17 @@
     },
     "AppScheduledTask": {
       "type": "object",
-      "required": [
-        "name"
-      ],
       "properties": {
         "name": {
           "type": "string"
         }
-      }
+      },
+      "required": [
+        "name"
+      ]
     },
     "AppVolume": {
       "type": "object",
-      "required": [
-        "mount",
-        "name"
-      ],
       "properties": {
         "mount": {
           "type": "string"
@@ -242,14 +306,117 @@
         "name": {
           "type": "string"
         }
+      },
+      "required": [
+        "name",
+        "mount"
+      ]
+    },
+    "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": "#/$defs/SshUserV1"
+          }
+        }
+      },
+      "additionalProperties": true
+    },
+    "ExecutableJob": {
+      "type": "object",
+      "properties": {
+        "capabilities": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/ExecutableJobCompatibilityMapV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "cli_args": {
+          "description": "CLI arguments passed to the runner.\nOnly 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": "#/$defs/PackageSource"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "volumes": {
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/AppVolume"
+          }
+        }
       }
     },
+    "ExecutableJobCompatibilityMapV1": {
+      "type": "object",
+      "properties": {
+        "memory": {
+          "description": "Instance memory settings.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/AppConfigCapabilityMemoryV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": true
+    },
     "HealthCheckHttpV1": {
       "description": "Health check configuration for http endpoints.",
       "type": "object",
-      "required": [
-        "path"
-      ],
       "properties": {
         "body": {
           "description": "Request body as a string.",
@@ -261,7 +428,7 @@
         "expect": {
           "anyOf": [
             {
-              "$ref": "#/definitions/HttpRequestExpect"
+              "$ref": "#/$defs/HttpRequestExpect"
             },
             {
               "type": "null"
@@ -275,7 +442,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/HttpHeader"
+            "$ref": "#/$defs/HttpHeader"
           }
         },
         "healthy_threshold": {
@@ -285,7 +452,7 @@
             "null"
           ],
           "format": "uint32",
-          "minimum": 0.0
+          "minimum": 0
         },
         "interval": {
           "description": "Interval for the health check.\n\nFormat: 1s, 5m, 11h, ...\n\nDefaults to 60s.",
@@ -307,9 +474,13 @@
         },
         "timeout": {
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
-          "type": [
-            "string",
-            "null"
+          "anyOf": [
+            {
+              "$ref": "#/$defs/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
         "unhealthy_threshold": {
@@ -319,33 +490,32 @@
             "null"
           ],
           "format": "uint32",
-          "minimum": 0.0
+          "minimum": 0
         }
-      }
+      },
+      "required": [
+        "path"
+      ]
     },
     "HealthCheckV1": {
       "oneOf": [
         {
           "type": "object",
-          "required": [
-            "http"
-          ],
           "properties": {
             "http": {
-              "$ref": "#/definitions/HealthCheckHttpV1"
+              "$ref": "#/$defs/HealthCheckHttpV1"
             }
           },
-          "additionalProperties": false
+          "additionalProperties": false,
+          "required": [
+            "http"
+          ]
         }
       ]
     },
     "HttpHeader": {
       "description": "Definition for an HTTP header.",
       "type": "object",
-      "required": [
-        "name",
-        "value"
-      ],
       "properties": {
         "name": {
           "type": "string"
@@ -353,14 +523,15 @@
         "value": {
           "type": "string"
         }
-      }
+      },
+      "required": [
+        "name",
+        "value"
+      ]
     },
     "HttpRequest": {
       "description": "Defines an HTTP request.",
       "type": "object",
-      "required": [
-        "path"
-      ],
       "properties": {
         "body": {
           "description": "Request body as a string.",
@@ -372,7 +543,7 @@
         "expect": {
           "anyOf": [
             {
-              "$ref": "#/definitions/HttpRequestExpect"
+              "$ref": "#/$defs/HttpRequestExpect"
             },
             {
               "type": "null"
@@ -386,7 +557,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/HttpHeader"
+            "$ref": "#/$defs/HttpHeader"
           }
         },
         "method": {
@@ -402,12 +573,19 @@
         },
         "timeout": {
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
-          "type": [
-            "string",
-            "null"
+          "anyOf": [
+            {
+              "$ref": "#/$defs/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
           ]
         }
-      }
+      },
+      "required": [
+        "path"
+      ]
     },
     "HttpRequestExpect": {
       "description": "Validation checks for an [`HttpRequest`].",
@@ -436,16 +614,140 @@
           "items": {
             "type": "integer",
             "format": "uint16",
-            "minimum": 0.0
+            "maximum": 65535,
+            "minimum": 0
           }
         }
       }
     },
-    "Locality": {
+    "InstabootSnapshotModeV1": {
+      "description": "How will an instance be bootstrapped?",
+      "oneOf": [
+        {
+          "description": "Start the instance without any snapshot triggers. Once the requests are done,\nuse `wasmer_wasix::WasiProcess::snapshot_and_stop` to capture a snapshot\nand shut the instance down.",
+          "type": "string",
+          "const": "bootstrap"
+        },
+        {
+          "description": "Explicitly enable the given snapshot triggers before starting the instance.\nThe instance's process will have its stop_running_after_checkpoint flag set,\nso the first snapshot will cause the instance to shut down.",
+          "type": "object",
+          "properties": {
+            "triggers": {
+              "type": "array",
+              "items": {
+                "$ref": "#/$defs/SnapshotTrigger"
+              }
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "triggers"
+          ]
+        }
+      ]
+    },
+    "Job": {
+      "description": "Job configuration.",
       "type": "object",
+      "properties": {
+        "action": {
+          "$ref": "#/$defs/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.\nThe calculation works by multiplying the time between invocations\nby 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",
+          "maximum": 255,
+          "minimum": 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.\nThe calculation works by multiplying the time between invocations\nby 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",
+          "maximum": 255,
+          "minimum": 0
+        },
+        "max_schedule_drift": {
+          "description": "Don't start job if past the due time by this amount,\ninstead opting to wait for the next instance of it\nto be triggered.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
+        "retries": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
+        "timeout": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "trigger": {
+          "$ref": "#/$defs/JobTrigger"
+        }
+      },
+      "additionalProperties": true,
       "required": [
-        "regions"
-      ],
+        "name",
+        "trigger",
+        "action"
+      ]
+    },
+    "JobAction": {
+      "type": "object",
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "fetch": {
+              "$ref": "#/$defs/HttpRequest"
+            }
+          },
+          "required": [
+            "fetch"
+          ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "execute": {
+              "$ref": "#/$defs/ExecutableJob"
+            }
+          },
+          "required": [
+            "execute"
+          ]
+        }
+      ]
+    },
+    "JobTrigger": {
+      "type": "string"
+    },
+    "Locality": {
+      "type": "object",
       "properties": {
         "regions": {
           "type": "array",
@@ -453,11 +755,55 @@
             "type": "string"
           }
         }
-      }
+      },
+      "required": [
+        "regions"
+      ]
     },
     "PackageSource": {
       "type": "string"
     },
+    "PasswordV1": {
+      "oneOf": [
+        {
+          "description": "Plain text password.",
+          "type": "object",
+          "properties": {
+            "password": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string",
+              "const": "plain"
+            }
+          },
+          "required": [
+            "type",
+            "password"
+          ]
+        },
+        {
+          "description": "Bcrypt password hash.",
+          "type": "object",
+          "properties": {
+            "hash": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string",
+              "const": "bcrypt"
+            }
+          },
+          "required": [
+            "type",
+            "hash"
+          ]
+        }
+      ]
+    },
+    "PrettyDuration": {
+      "type": "string"
+    },
     "Redirect": {
       "description": "App redirect configuration.",
       "type": "object",
@@ -470,6 +816,42 @@
           ]
         }
       }
+    },
+    "SnapshotTrigger": {
+      "type": "string"
+    },
+    "SshUserV1": {
+      "type": "object",
+      "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": "#/$defs/PasswordV1"
+          }
+        },
+        "username": {
+          "description": "The username used for SSH login.",
+          "type": "string"
+        }
+      },
+      "additionalProperties": true,
+      "required": [
+        "username"
+      ]
     }
   }
 }
\ No newline at end of file
diff --git a/examples/compiler_cranelift.rs b/examples/compiler_cranelift.rs
index cb8b8f9192..14493e84f5 100644
--- a/examples/compiler_cranelift.rs
+++ b/examples/compiler_cranelift.rs
@@ -10,7 +10,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer::{Instance, Module, Store, Value, imports, wat2wasm};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -52,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // slice of `Value`s. The results are a boxed slice of `Value`s.
     let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
 
-    println!("Results: {:?}", results);
+    println!("Results: {results:?}");
     assert_eq!(results.to_vec(), vec![Value::I32(3)]);
 
     Ok(())
diff --git a/examples/compiler_llvm.rs b/examples/compiler_llvm.rs
index 2622227259..4a7f60e2b4 100644
--- a/examples/compiler_llvm.rs
+++ b/examples/compiler_llvm.rs
@@ -10,7 +10,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer::{Instance, Module, Store, Value, imports, wat2wasm};
 use wasmer_compiler_llvm::LLVM;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -52,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // slice of `Value`s. The results are a boxed slice of `Value`s.
     let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
 
-    println!("Results: {:?}", results);
+    println!("Results: {results:?}");
     assert_eq!(results.to_vec(), vec![Value::I32(3)]);
 
     Ok(())
diff --git a/examples/compiler_singlepass.rs b/examples/compiler_singlepass.rs
index 01fb181b12..931e33db34 100644
--- a/examples/compiler_singlepass.rs
+++ b/examples/compiler_singlepass.rs
@@ -10,7 +10,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer::{Instance, Module, Store, Value, imports, wat2wasm};
 use wasmer_compiler_singlepass::Singlepass;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -52,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // slice of `Value`s. The results are a boxed slice of `Value`s.
     let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
 
-    println!("Results: {:?}", results);
+    println!("Results: {results:?}");
     assert_eq!(results.to_vec(), vec![Value::I32(3)]);
 
     Ok(())
diff --git a/examples/early_exit.rs b/examples/early_exit.rs
index 95d9a801cc..154c06bf7f 100644
--- a/examples/early_exit.rs
+++ b/examples/early_exit.rs
@@ -16,7 +16,7 @@
 
 use anyhow::bail;
 use std::fmt;
-use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, TypedFunction};
+use wasmer::{Function, Instance, Module, Store, TypedFunction, imports, wat2wasm};
 
 // First we need to create an error type that we'll use to signal the end of execution.
 #[derive(Debug, Clone, Copy)]
@@ -78,27 +78,24 @@ fn main() -> anyhow::Result<()> {
     // Get the `run` function which we'll use as our entrypoint.
     println!("Calling `run` function...");
     let run_func: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "run")?;
+        instance.exports.get_typed_function(&store, "run")?;
 
     // When we call a function it can either succeed or fail. We expect it to fail.
     match run_func.call(&mut store, 1, 7) {
         Ok(result) => {
-            bail!(
-                "Expected early termination with `ExitCode`, found: {}",
-                result
-            );
+            bail!("Expected early termination with `ExitCode`, found: {result}");
         }
         // In case of a failure, which we expect, we attempt to downcast the error into the error
         // type that we were expecting.
         Err(e) => match e.downcast::<ExitCode>() {
             // We found the exit code used to terminate execution.
             Ok(exit_code) => {
-                println!("Exited early with exit code: {}", exit_code);
+                println!("Exited early with exit code: {exit_code}");
 
                 Ok(())
             }
             Err(e) => {
-                bail!("Unknown error `{}` found. expected `ErrorCode`", e);
+                bail!("Unknown error `{e}` found. expected `ExitCode`");
             }
         },
     }
diff --git a/examples/engine.rs b/examples/engine.rs
index 1bb2001610..0aae886761 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::{Instance, Module, Store, Value, imports, sys::EngineBuilder, wat2wasm};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -78,7 +78,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let sum = instance.exports.get_function("sum")?;
     let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
 
-    println!("Results: {:?}", results);
+    println!("Results: {results:?}");
     assert_eq!(results.to_vec(), vec![Value::I32(3)]);
 
     Ok(())
diff --git a/examples/engine_cross_compilation.rs b/examples/engine_cross_compilation.rs
index 9021694182..c4a2856d3b 100644
--- a/examples/engine_cross_compilation.rs
+++ b/examples/engine_cross_compilation.rs
@@ -19,9 +19,13 @@
 //! Ready?
 
 use std::str::FromStr;
-use wasmer::{wat2wasm, EngineBuilder, Module, RuntimeError, Store};
+use wasmer::{
+    Module, RuntimeError, Store,
+    sys::{CpuFeature, EngineBuilder},
+    wat2wasm,
+};
 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.
@@ -62,7 +66,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     // Let's build the target.
     let target = Target::new(triple, cpu_feature);
-    println!("Chosen target: {:?}", target);
+    println!("Chosen target: {target:?}");
 
     // Define the engine that will drive everything.
     //
diff --git a/examples/engine_headless.rs b/examples/engine_headless.rs
index c0cbf2b334..ec75248c51 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::{Instance, Module, Store, Value, imports, sys::EngineBuilder, wat2wasm};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -122,7 +122,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         let sum = instance.exports.get_function("sum")?;
         let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
 
-        println!("Results: {:?}", results);
+        println!("Results: {results:?}");
         assert_eq!(results.to_vec(), vec![Value::I32(3)]);
     }
 
diff --git a/examples/errors.rs b/examples/errors.rs
index c034c409de..98de26f599 100644
--- a/examples/errors.rs
+++ b/examples/errors.rs
@@ -13,7 +13,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction};
+use wasmer::{Instance, Module, Store, TypedFunction, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
@@ -60,7 +60,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let div_by_zero: TypedFunction<(), i32> = instance
         .exports
         .get_function("div_by_zero")?
-        .typed(&mut store)?;
+        .typed(&store)?;
 
     println!("Calling `div_by_zero` function...");
     // Let's call the `div_by_zero` exported function.
@@ -81,12 +81,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             let frames = e.trace();
             let frames_len = frames.len();
 
-            for i in 0..frames_len {
+            for (i, frame) in frames.iter().enumerate() {
                 println!(
                     "  Frame #{}: {:?}::{:?}",
                     frames_len - i,
-                    frames[i].module_name(),
-                    frames[i].function_name().or(Some("<func>")).unwrap()
+                    frame.module_name(),
+                    frame.function_name().unwrap_or("<func>")
                 );
             }
         }
diff --git a/examples/exports_function.rs b/examples/exports_function.rs
index e984322cf2..2c420f31f8 100644
--- a/examples/exports_function.rs
+++ b/examples/exports_function.rs
@@ -17,7 +17,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction, Value};
+use wasmer::{Instance, Module, Store, TypedFunction, Value, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
@@ -70,7 +70,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = [Value::I32(1), Value::I32(2)];
     let result = sum.call(&mut store, &args)?;
 
-    println!("Results: {:?}", result);
+    println!("Results: {result:?}");
     assert_eq!(result.to_vec(), vec![Value::I32(3)]);
 
     // That was fun. But what if we can get rid of the `Value`s? Well,
@@ -81,7 +81,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // `Rets`, respectively for the parameters and the results. If
     // those values don't match the exported function signature, an
     // error will be raised.
-    let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&mut store)?;
+    let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&store)?;
 
     println!("Calling `sum` function (natively)...");
     // Let's call the `sum` exported function. The parameters are
@@ -89,7 +89,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // result, in this case particular case, in a unit of type `i32`.
     let result = sum_typed.call(&mut store, 3, 4)?;
 
-    println!("Results: {:?}", result);
+    println!("Results: {result:?}");
     assert_eq!(result, 7);
 
     // Much nicer, isn't it?
diff --git a/examples/exports_global.rs b/examples/exports_global.rs
index cdb8455acb..2f51af5f2a 100644
--- a/examples/exports_global.rs
+++ b/examples/exports_global.rs
@@ -15,7 +15,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Mutability, Store, Type, TypedFunction, Value};
+use wasmer::{Instance, Module, Mutability, Store, Type, TypedFunction, Value, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
@@ -83,18 +83,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     // We will use an exported function for the `one` global
     // and the Global API for `some`.
-    let get_one: TypedFunction<(), f32> = instance
-        .exports
-        .get_function("get_one")?
-        .typed(&mut store)?;
+    let get_one: TypedFunction<(), f32> =
+        instance.exports.get_function("get_one")?.typed(&store)?;
 
     let one_value = get_one.call(&mut store)?;
     let some_value = some.get(&mut store);
 
-    println!("`one` value: {:?}", one_value);
+    println!("`one` value: {one_value:?}");
     assert_eq!(one_value, 1.0);
 
-    println!("`some` value: {:?}", some_value);
+    println!("`some` value: {some_value:?}");
     assert_eq!(some_value, Value::F32(0.0));
 
     println!("Setting global values...");
@@ -109,7 +107,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // );
 
     let one_result = one.get(&mut store);
-    println!("`one` value after `set`: {:?}", one_result);
+    println!("`one` value after `set`: {one_result:?}");
     assert_eq!(one_result, Value::F32(1.0));
 
     // Setting the values of globals can be done in two ways:
@@ -117,18 +115,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //   2. Using the Global API directly.
     //
     // We will use both for the `some` global.
-    let set_some: TypedFunction<f32, ()> = instance
-        .exports
-        .get_function("set_some")?
-        .typed(&mut store)?;
+    let set_some: TypedFunction<f32, ()> =
+        instance.exports.get_function("set_some")?.typed(&store)?;
     set_some.call(&mut store, 21.0)?;
     let some_result = some.get(&mut store);
-    println!("`some` value after `set_some`: {:?}", some_result);
+    println!("`some` value after `set_some`: {some_result:?}");
     assert_eq!(some_result, Value::F32(21.0));
 
     some.set(&mut store, Value::F32(42.0))?;
     let some_result = some.get(&mut store);
-    println!("`some` value after `set`: {:?}", some_result);
+    println!("`some` value after `set`: {some_result:?}");
     assert_eq!(some_result, Value::F32(42.0));
 
     Ok(())
diff --git a/examples/exports_memory.rs b/examples/exports_memory.rs
index 3990efca3e..5b5b988b1e 100644
--- a/examples/exports_memory.rs
+++ b/examples/exports_memory.rs
@@ -11,7 +11,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction, WasmPtr};
+use wasmer::{Instance, Module, Store, TypedFunction, WasmPtr, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
@@ -46,7 +46,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
     let load: TypedFunction<(), (WasmPtr<u8>, i32)> =
-        instance.exports.get_typed_function(&mut store, "load")?;
+        instance.exports.get_typed_function(&store, "load")?;
 
     // Here we go.
     //
@@ -69,7 +69,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // which will tell us the offset and length of the string.
     let (ptr, length) = load.call(&mut store)?;
     println!("String offset: {:?}", ptr.offset());
-    println!("String length: {:?}", length);
+    println!("String length: {length:?}");
 
     // We now know where to find our string, let's read it.
     //
@@ -77,7 +77,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // decode them into a string.
     let memory_view = memory.view(&store);
     let str = ptr.read_utf8_string(&memory_view, length as u32).unwrap();
-    println!("Memory contents: {:?}", str);
+    println!("Memory contents: {str:?}");
 
     // What about changing the contents of the memory with a more
     // appropriate string?
@@ -86,8 +86,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // of each element.
     let new_str = b"Hello, Wasmer!";
     let values = ptr.slice(&memory_view, new_str.len() as u32).unwrap();
-    for i in 0..new_str.len() {
-        values.index(i as u64).write(new_str[i]).unwrap();
+    for (i, &str) in new_str.iter().enumerate() {
+        values.index(i as u64).write(str).unwrap();
     }
 
     // And now, let's see the result.
@@ -100,7 +100,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let str = ptr
         .read_utf8_string(&memory_view, new_str.len() as u32)
         .unwrap();
-    println!("New memory contents: {:?}", str);
+    println!("New memory contents: {str:?}");
 
     // Much better, don't you think?
 
diff --git a/examples/features.rs b/examples/features.rs
index 28ea86e7e3..5b7fce12e9 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::{
+    Instance, Module, Store, Value, imports,
+    sys::{EngineBuilder, Features},
+    wat2wasm,
+};
 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..b555ecad91
--- /dev/null
+++ b/examples/funcref.rs
@@ -0,0 +1,75 @@
+use std::error::Error;
+use wasmer::{Instance, Module, Store, Table, TableType, Type, Value, imports};
+
+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/hello_world.rs b/examples/hello_world.rs
index 83d16ff6f7..60aeadf7e2 100644
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -6,7 +6,7 @@
 //! cargo run --example hello-world --release --features "cranelift"
 //! ```
 
-use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, TypedFunction};
+use wasmer::{Function, Instance, Module, Store, TypedFunction, imports, wat2wasm};
 
 fn main() -> anyhow::Result<()> {
     // First we create a simple Wasm program to use with Wasmer.
@@ -65,7 +65,7 @@ fn main() -> anyhow::Result<()> {
     //
     // Recall that the Wasm module exported a function named "run", this is getting
     // that exported function from the `Instance`.
-    let run_func: TypedFunction<(), ()> = instance.exports.get_typed_function(&mut store, "run")?;
+    let run_func: TypedFunction<(), ()> = instance.exports.get_typed_function(&store, "run")?;
 
     // Finally, we call our exported Wasm function which will call our "say_hello"
     // function and return.
diff --git a/examples/http_dynamic_size.rs b/examples/http_dynamic_size.rs
index 91317f989c..99b287dc7a 100644
--- a/examples/http_dynamic_size.rs
+++ b/examples/http_dynamic_size.rs
@@ -1,7 +1,7 @@
 use anyhow::Result;
 use wasmer::{
-    imports, wat2wasm, AsStoreRef, Function, FunctionEnv, FunctionEnvMut, Instance, Memory,
-    MemoryView, Module, Store, WasmPtr,
+    AsStoreRef, Function, FunctionEnv, FunctionEnvMut, Instance, Memory, MemoryView, Module, Store,
+    WasmPtr, imports, wat2wasm,
 };
 
 // Utils
@@ -38,16 +38,7 @@ fn http_get(mut ctx: FunctionEnvMut<ExampleEnv>, url: u32, url_len: u32) -> u32
 
         // Get request
         let response = ureq::get(&address).call().unwrap();
-        let capacity = match response
-            .header("Content-Length")
-            .map(|it| it.parse::<usize>())
-        {
-            Some(Ok(len)) => len,
-            _ => 1024,
-        };
-        let mut buffer = Vec::with_capacity(capacity);
-        let mut reader = response.into_reader();
-        reader.read_to_end(&mut buffer).unwrap();
+        let buffer = response.into_body().read_to_vec().unwrap();
         (buffer, memory_size)
     };
 
diff --git a/examples/imports_exports.rs b/examples/imports_exports.rs
index bb430b15cf..ed833a3930 100644
--- a/examples/imports_exports.rs
+++ b/examples/imports_exports.rs
@@ -16,8 +16,8 @@
 //! Ready?
 
 use wasmer::{
-    imports, wat2wasm, Function, FunctionType, Global, Instance, Memory, Module, Store, Table,
-    Type, Value,
+    Function, FunctionType, Global, Instance, Memory, Module, Store, Table, Type, Value, imports,
+    wat2wasm,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/examples/imports_function.rs b/examples/imports_function.rs
index b8eff999a9..634f0ffa2a 100644
--- a/examples/imports_function.rs
+++ b/examples/imports_function.rs
@@ -18,8 +18,8 @@
 //! Ready?
 
 use wasmer::{
-    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Module,
-    Store, Type, TypedFunction, Value,
+    Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Module, Store, Type,
+    TypedFunction, Value, imports, wat2wasm,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -56,7 +56,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         let result = args[0].unwrap_i32() * 2;
 
-        println!("Result of `multiply_dynamic`: {:?}", result);
+        println!("Result of `multiply_dynamic`: {result:?}");
 
         Ok(vec![Value::I32(result)])
     });
@@ -65,7 +65,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         println!("Calling `multiply_typed`...");
         let result = a * 3;
 
-        println!("Result of `multiply_typed`: {:?}", result);
+        println!("Result of `multiply_typed`: {result:?}");
 
         result
     }
@@ -87,14 +87,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     // The Wasm module exports a function called `sum`. Let's get it.
     let sum: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_function("sum")?.typed(&mut store)?;
+        instance.exports.get_function("sum")?.typed(&store)?;
 
     println!("Calling `sum` function...");
     // Let's call the `sum` exported function. It will call each
     // of the imported functions.
     let result = sum.call(&mut store, 1, 2)?;
 
-    println!("Results of `sum`: {:?}", result);
+    println!("Results of `sum`: {result:?}");
     assert_eq!(result, 8);
 
     Ok(())
diff --git a/examples/imports_function_env.rs b/examples/imports_function_env.rs
index fa0f338dd3..d84400aeb8 100644
--- a/examples/imports_function_env.rs
+++ b/examples/imports_function_env.rs
@@ -21,8 +21,8 @@
 
 use std::sync::{Arc, Mutex};
 use wasmer::{
-    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, Instance, Module, Store,
-    TypedFunction,
+    Function, FunctionEnv, FunctionEnvMut, Instance, Module, Store, TypedFunction, imports,
+    wat2wasm,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -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)))
@@ -108,10 +108,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let increment_counter_loop: TypedFunction<i32, i32> = instance
         .exports
         .get_function("increment_counter_loop")?
-        .typed(&mut store)?;
+        .typed(&store)?;
 
     let counter_value: i32 = *shared_counter.lock().unwrap();
-    println!("Initial ounter value: {:?}", counter_value);
+    println!("Initial counter value: {counter_value:?}");
 
     println!("Calling `increment_counter_loop` function...");
     // Let's call the `increment_counter_loop` exported function.
@@ -120,10 +120,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = increment_counter_loop.call(&mut store, 5)?;
 
     let counter_value: i32 = *shared_counter.lock().unwrap();
-    println!("New counter value (host): {:?}", counter_value);
+    println!("New counter value (host): {counter_value:?}");
     assert_eq!(counter_value, 5);
 
-    println!("New counter value (guest): {:?}", result);
+    println!("New counter value (guest): {result:?}");
     assert_eq!(result, 5);
 
     Ok(())
diff --git a/examples/imports_function_env_global.rs b/examples/imports_function_env_global.rs
index 46126f98bb..7a62d75414 100644
--- a/examples/imports_function_env_global.rs
+++ b/examples/imports_function_env_global.rs
@@ -22,8 +22,8 @@
 
 use std::sync::{Arc, Mutex};
 use wasmer::{
-    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, Global, Instance, Module, Store,
-    TypedFunction, Value,
+    Function, FunctionEnv, FunctionEnvMut, Global, Instance, Module, Store, TypedFunction, Value,
+    imports, wat2wasm,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -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)))
@@ -122,10 +122,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let increment_counter_loop: TypedFunction<i32, i32> = instance
         .exports
         .get_function("increment_counter_loop")?
-        .typed(&mut store)?;
+        .typed(&store)?;
 
     let counter_value: i32 = *shared_counter.lock().unwrap();
-    println!("Initial ounter value: {:?}", counter_value);
+    println!("Initial counter value: {counter_value:?}");
 
     println!("Calling `increment_counter_loop` function...");
     // Let's call the `increment_counter_loop` exported function.
@@ -134,14 +134,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = increment_counter_loop.call(&mut store, 5)?;
 
     let counter_value: i32 = *shared_counter.lock().unwrap();
-    println!("New counter value (host): {:?}", counter_value);
+    println!("New counter value (host): {counter_value:?}");
     assert_eq!(counter_value, 5);
 
-    println!("New counter value (guest): {:?}", result);
+    println!("New counter value (guest): {result:?}");
     assert_eq!(result, 5);
 
     let global_counter = g_counter.get(&mut store);
-    println!("New global counter value: {:?}", global_counter);
+    println!("New global counter value: {global_counter:?}");
     assert_eq!(global_counter.unwrap_i32(), 10);
 
     Ok(())
diff --git a/examples/imports_global.rs b/examples/imports_global.rs
index 7080f6b229..5d03c8bf12 100644
--- a/examples/imports_global.rs
+++ b/examples/imports_global.rs
@@ -15,7 +15,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Global, Instance, Module, Store, TypedFunction, Value};
+use wasmer::{Global, Instance, Module, Store, TypedFunction, Value, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
@@ -60,21 +60,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     // The Wasm module only imports some globals. We'll have to interact
     // with them either using the Global API or exported functions.
-    let get_some: TypedFunction<(), f32> = instance
-        .exports
-        .get_function("get_some")?
-        .typed(&mut store)?;
-    let get_other: TypedFunction<(), f32> = instance
-        .exports
-        .get_function("get_other")?
-        .typed(&mut store)?;
+    let get_some: TypedFunction<(), f32> =
+        instance.exports.get_function("get_some")?.typed(&store)?;
+    let get_other: TypedFunction<(), f32> =
+        instance.exports.get_function("get_other")?.typed(&store)?;
 
     let some_result = get_some.call(&mut store)?;
     let other_result = get_other.call(&mut store)?;
 
-    println!("some value (via `get_some`): {:?}", some_result);
+    println!("some value (via `get_some`): {some_result:?}");
     println!("some value (via Global API): {:?}", some.get(&mut store));
-    println!("other value (via `get_other`): {:?}", other_result);
+    println!("other value (via `get_other`): {other_result:?}");
     println!("other value (via Global API): {:?}", other.get(&mut store));
 
     assert_eq!(some_result, some.get(&mut store).f32().unwrap());
@@ -88,16 +84,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     other.set(&mut store, Value::F32(21.0))?;
     let other_result = other.get(&mut store);
-    println!("other value after `set`: {:?}", other_result);
+    println!("other value after `set`: {other_result:?}");
     assert_eq!(other_result, Value::F32(21.0));
 
     println!("Altering global values through exported functions...");
     // Changes made to global through exported functions will
     // be reflected on the host side.
-    let set_other: TypedFunction<f32, ()> = instance
-        .exports
-        .get_function("set_other")?
-        .typed(&mut store)?;
+    let set_other: TypedFunction<f32, ()> =
+        instance.exports.get_function("set_other")?.typed(&store)?;
     set_other.call(&mut store, 42.0)?;
 
     println!("other value (via Global API): {:?}", other.get(&mut store));
diff --git a/examples/instance.rs b/examples/instance.rs
index 35cc70748e..e6bba7f895 100644
--- a/examples/instance.rs
+++ b/examples/instance.rs
@@ -14,7 +14,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction};
+use wasmer::{Instance, Module, Store, TypedFunction, imports, wat2wasm};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module.
@@ -58,15 +58,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Here we are retrieving the exported function. We won't go into details here
     // as the main focus of this example is to show how to create an instance out
     // of a Wasm module and have basic interactions with it.
-    let add_one: TypedFunction<i32, i32> = instance
-        .exports
-        .get_function("add_one")?
-        .typed(&mut store)?;
+    let add_one: TypedFunction<i32, i32> =
+        instance.exports.get_function("add_one")?.typed(&store)?;
 
     println!("Calling `add_one` function...");
     let result = add_one.call(&mut store, 1)?;
 
-    println!("Results of `add_one`: {:?}", result);
+    println!("Results of `add_one`: {result:?}");
     assert_eq!(result, 2);
 
     Ok(())
diff --git a/examples/memory.rs b/examples/memory.rs
index 15ed18cc90..8455ef27ab 100644
--- a/examples/memory.rs
+++ b/examples/memory.rs
@@ -14,8 +14,9 @@
 //!
 //! Ready?
 
+#[cfg(not(feature = "wamr"))]
 use std::mem;
-use wasmer::{imports, wat2wasm, Bytes, Instance, Module, Pages, Store, TypedFunction};
+use wasmer::{Bytes, Instance, Module, Pages, Store, TypedFunction, imports, wat2wasm};
 
 // this example is a work in progress:
 // TODO: clean it up and comment it https://github.com/wasmerio/wasmer/issues/1749
@@ -68,13 +69,13 @@ fn main() -> anyhow::Result<()> {
     // The module exports some utility functions, let's get them.
     //
     // These function will be used later in this example.
-    let mem_size: TypedFunction<(), i32> = instance
-        .exports
-        .get_typed_function(&mut store, "mem_size")?;
-    let get_at: TypedFunction<i32, i32> =
-        instance.exports.get_typed_function(&mut store, "get_at")?;
+    let mem_size: TypedFunction<(), i32> =
+        instance.exports.get_typed_function(&store, "mem_size")?;
+    #[cfg(not(feature = "wamr"))]
+    let get_at: TypedFunction<i32, i32> = instance.exports.get_typed_function(&store, "get_at")?;
+    #[cfg(not(feature = "wamr"))]
     let set_at: TypedFunction<(i32, i32), ()> =
-        instance.exports.get_typed_function(&mut store, "set_at")?;
+        instance.exports.get_typed_function(&store, "set_at")?;
     let memory = instance.exports.get_memory("memory")?;
 
     // We now have an instance ready to be used.
@@ -90,7 +91,7 @@ fn main() -> anyhow::Result<()> {
     println!("Querying memory size...");
     let memory_view = memory.view(&store);
     assert_eq!(memory_view.size(), Pages::from(1));
-    assert_eq!(memory_view.size().bytes(), Bytes::from(65536 as usize));
+    assert_eq!(memory_view.size().bytes(), Bytes::from(65536_usize));
     assert_eq!(memory_view.data_size(), 65536);
 
     // Sometimes, the guest module may also export a function to let you
@@ -98,7 +99,7 @@ fn main() -> anyhow::Result<()> {
     let result = mem_size.call(&mut store)?;
 
     let memory_view = memory.view(&store);
-    println!("Memory size: {:?}", result);
+    println!("Memory size: {result:?}");
     assert_eq!(Pages::from(result as u32), memory_view.size());
 
     // Now that we know the size of our memory, it's time to see how wa
@@ -108,37 +109,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..1ea7992515
--- /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::{Instance, Module, Store, imports, wat2wasm};
+
+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..8e7a513688 100644
--- a/examples/metering.rs
+++ b/examples/metering.rs
@@ -17,12 +17,15 @@
 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::{
+    Instance, Module, Store, TypedFunction, imports,
+    sys::{CompilerConfig, EngineBuilder},
+    wat2wasm,
+};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_middlewares::{
-    metering::{get_remaining_points, set_remaining_points, MeteringPoints},
     Metering,
+    metering::{MeteringPoints, get_remaining_points, set_remaining_points},
 };
 
 fn main() -> anyhow::Result<()> {
@@ -86,10 +89,8 @@ fn main() -> anyhow::Result<()> {
     //
     // Our module exports a single `add_one`  function. We want to
     // measure the cost of executing this function.
-    let add_one: TypedFunction<i32, i32> = instance
-        .exports
-        .get_function("add_one")?
-        .typed(&mut store)?;
+    let add_one: TypedFunction<i32, i32> =
+        instance.exports.get_function("add_one")?.typed(&store)?;
 
     println!("Calling `add_one` function once...");
     add_one.call(&mut store, 1)?;
@@ -106,10 +107,7 @@ fn main() -> anyhow::Result<()> {
         MeteringPoints::Remaining(6)
     );
 
-    println!(
-        "Remaining points after the first call: {:?}",
-        remaining_points_after_first_call
-    );
+    println!("Remaining points after the first call: {remaining_points_after_first_call:?}");
 
     println!("Calling `add_one` function twice...");
     add_one.call(&mut store, 1)?;
@@ -122,10 +120,7 @@ fn main() -> anyhow::Result<()> {
         MeteringPoints::Remaining(2)
     );
 
-    println!(
-        "Remaining points after the second call: {:?}",
-        remaining_points_after_second_call
-    );
+    println!("Remaining points after the second call: {remaining_points_after_second_call:?}");
 
     // Because calling our `add_one` function consumes 4 points,
     // calling it a third time will fail: we already consume 8
@@ -133,10 +128,7 @@ fn main() -> anyhow::Result<()> {
     println!("Calling `add_one` function a third time...");
     match add_one.call(&mut store, 1) {
         Ok(result) => {
-            bail!(
-                "Expected failure while calling `add_one`, found: {}",
-                result
-            );
+            bail!("Expected failure while calling `add_one`, found: {result}");
         }
         Err(_) => {
             println!("Calling `add_one` failed.");
@@ -161,7 +153,7 @@ fn main() -> anyhow::Result<()> {
     let remaining_points = get_remaining_points(&mut store, &instance);
     assert_eq!(remaining_points, MeteringPoints::Remaining(new_limit));
 
-    println!("Remaining points: {:?}", remaining_points);
+    println!("Remaining points: {remaining_points:?}");
 
     Ok(())
 }
diff --git a/examples/platform_ios_headless.rs b/examples/platform_ios_headless.rs
index 7b133b2db0..69c70ec050 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::{Module, RuntimeError, Store, sys::CpuFeature, wat2wasm};
 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..b3557acfa9 100644
--- a/examples/table.rs
+++ b/examples/table.rs
@@ -1,5 +1,5 @@
 use wasmer::{
-    imports, wat2wasm, Function, Instance, Module, Store, TableType, Type, TypedFunction, Value,
+    Function, Instance, Module, Store, TableType, Type, TypedFunction, Value, imports, wat2wasm,
 };
 
 /// A function we'll call through a table.
@@ -61,7 +61,7 @@ fn main() -> anyhow::Result<()> {
     // to be passed to the function found in the table.
     let call_via_table: TypedFunction<(i32, i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut store, "call_callback")?;
+        .get_typed_function(&store, "call_callback")?;
 
     // And then call it with table index 1 and arguments 2 and 7.
     let result = call_via_table.call(&mut store, 1, 2, 7)?;
@@ -72,7 +72,7 @@ fn main() -> anyhow::Result<()> {
     // We then get the table from the instance.
     let guest_table = instance.exports.get_table("__indirect_function_table")?;
     // And demonstrate that it has the properties that we set in the Wasm.
-    assert_eq!(guest_table.size(&mut store), 3);
+    assert_eq!(guest_table.size(&store), 3);
     assert_eq!(
         guest_table.ty(&store),
         TableType {
@@ -106,7 +106,7 @@ fn main() -> anyhow::Result<()> {
     let previous_size = guest_table.grow(&mut store, 3, func.into())?;
     assert_eq!(previous_size, 3);
 
-    assert_eq!(guest_table.size(&mut store), 6);
+    assert_eq!(guest_table.size(&store), 6);
     assert_eq!(
         guest_table.ty(&store),
         TableType {
@@ -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/throw_exception.rs b/examples/throw_exception.rs
new file mode 100644
index 0000000000..df36c8a4e5
--- /dev/null
+++ b/examples/throw_exception.rs
@@ -0,0 +1,146 @@
+use std::sync::{Arc, atomic::AtomicUsize};
+
+use wasmer::{
+    Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Module, RuntimeError, Store,
+    Type, TypedFunction, Value, imports, sys::Target, wat2wasm,
+};
+use wasmer_types::Features;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (tag $exn (import "env" "tag") (param i32))
+  (func $log (import "env" "log") (param i32))
+  (func $throw1 (import "env" "throw1"))
+  (func $throw2 (import "env" "throw2"))
+
+  (func $f (export "f")
+    (local $e exnref)
+    (block $outer (result i32 exnref)
+      (try_table (catch_ref $exn $outer)
+        call $throw2
+        unreachable
+      )
+      unreachable
+    )
+    drop
+    call $log
+    (block $outer2 (result i32 exnref)
+      (try_table (catch_ref $exn $outer2)
+        call $throw1
+        unreachable
+      )
+      unreachable
+    )
+    local.set $e
+    call $log
+    local.get $e
+    throw_ref
+  )
+)
+"#,
+    )?;
+
+    // We need an LLVM backend with the exception handling feature enabled.
+    let target = Target::default();
+    let features = Features::detect_from_wasm(&wasm_bytes).unwrap();
+
+    let config = wasmer_compiler_llvm::LLVM::new();
+    let engine = wasmer_compiler::EngineBuilder::new(config)
+        .set_features(Some(features))
+        .set_target(Some(target))
+        .engine();
+
+    // Create a Store.
+    let mut store = Store::new(engine);
+
+    // Declare a tag.
+    let tag = wasmer::Tag::new(&mut store, vec![Type::I32]);
+
+    // Store the tag in an environment so we can access it in the `throw` function.
+    struct MyEnv {
+        tag: wasmer::Tag,
+    }
+    let env = FunctionEnv::new(&mut store, MyEnv { tag: tag.clone() });
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    let log_count = Arc::new(AtomicUsize::new(0));
+
+    // Create the functions
+    let log_wasm_value = {
+        let log_count = log_count.clone();
+        move |param: i32| {
+            println!("Logging from wasm: {param}");
+            log_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        }
+    };
+    let log = Function::new_typed(&mut store, log_wasm_value);
+
+    // Both Function::new_with_env and Function::new_typed_with_env can throw
+    // exceptions if they return a Result with a RuntimeError.
+    fn throw1(
+        mut env: FunctionEnvMut<MyEnv>,
+        _params: &[Value],
+    ) -> Result<Vec<Value>, RuntimeError> {
+        println!("Throwing exception 1");
+
+        // To "throw" an exception from native code, we create a new one and
+        // return it wrapped in a `RuntimeError`. The Wasmer runtime will
+        // recognize it and will start the unwinding process.
+        let (env, mut ctx) = env.data_and_store_mut();
+        let exn = wasmer::Exception::new(&mut ctx, &env.tag, &[Value::I32(69)]);
+        Err(RuntimeError::exception(&ctx, exn))
+    }
+    let throw1 =
+        Function::new_with_env(&mut store, &env, FunctionType::new(vec![], vec![]), throw1);
+
+    fn throw2(mut env: FunctionEnvMut<MyEnv>) -> Result<(), RuntimeError> {
+        println!("Throwing exception 2");
+        let (env, mut ctx) = env.data_and_store_mut();
+        let exn = wasmer::Exception::new(&mut ctx, &env.tag, &[Value::I32(42)]);
+        Err(RuntimeError::exception(&ctx, exn))
+    }
+    let throw2 = Function::new_typed_with_env(&mut store, &env, throw2);
+
+    // Create an import object.
+    let import_object = imports! {
+        "env" => {
+            "tag" => tag,
+            "log" => log,
+            "throw1" => throw1,
+            "throw2" => throw2,
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    let f: TypedFunction<(), ()> = instance.exports.get_function("f")?.typed(&store)?;
+
+    println!("Calling `f` function...");
+    let result = f.call(&mut store);
+
+    // Now we can inspect the exception, since it was propagated back to us.
+    let err = result.unwrap_err();
+    let exn = err.to_exception().expect("should be an exception");
+    let values = exn.payload(&mut store);
+    println!("Caught exception with payload: {values:?}");
+
+    assert_eq!(values, vec![Value::I32(69)]);
+    assert_eq!(log_count.load(std::sync::atomic::Ordering::SeqCst), 2);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_throw_exception() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/examples/tunables_limit_memory.rs b/examples/tunables_limit_memory.rs
index da2c7a4ece..d3265f2764 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,
+    Engine, Instance, Memory, MemoryError, MemoryStyle, MemoryType, Module, Pages, Store,
+    TableStyle, TableType, imports,
+    sys::{
+        BaseTunables, NativeEngineExt, Target, Tunables,
+        vm::{VMMemory, VMMemoryDefinition, VMTable, VMTableDefinition},
+    },
+    wat2wasm,
 };
-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.
 ///
@@ -33,7 +35,7 @@ impl<T: Tunables> LimitingTunables<T> {
     /// valid. However, this can produce invalid types, such that
     /// validate_memory must be called before creating the memory.
     fn adjust_memory(&self, requested: &MemoryType) -> MemoryType {
-        let mut adjusted = requested.clone();
+        let mut adjusted = *requested;
         if requested.maximum.is_none() {
             adjusted.maximum = Some(self.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,17 +102,19 @@ 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
-            .create_vm_memory(&adjusted, style, vm_definition_location)
+        unsafe {
+            self.base
+                .create_vm_memory(&adjusted, style, vm_definition_location)
+        }
     }
 
     /// 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,8 +126,8 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         ty: &TableType,
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
-    ) -> Result<vm::VMTable, String> {
-        self.base.create_vm_table(ty, style, vm_definition_location)
+    ) -> Result<VMTable, String> {
+        unsafe { self.base.create_vm_table(ty, style, vm_definition_location) }
     }
 }
 
@@ -167,7 +171,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     assert_eq!(memories.len(), 1);
 
     let first_memory = memories.pop().unwrap();
-    println!("Memory of this instance: {:?}", first_memory);
+    println!("Memory of this instance: {first_memory:?}");
     assert_eq!(first_memory.ty(&store).maximum.unwrap(), Pages(24));
 
     Ok(())
diff --git a/examples/wasi.rs b/examples/wasi.rs
index c055d356a8..0dfab7cb20 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::{
+    Pipe, PluggableRuntime, Runtime,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+    runtime::{module_cache::HashedModuleData, task_manager::tokio::TokioTaskManager},
+};
 
 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::new(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..b33ee03443 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::{
+    Pipe,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let wasm_path = concat!(
@@ -23,33 +27,50 @@ 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);
+    println!("Writing \"{msg}\" to the WASI stdin...");
     let (mut stdin_sender, stdin_reader) = Pipe::channel();
     let (stdout_sender, mut stdout_reader) = Pipe::channel();
 
     // To write to the stdin
-    writeln!(stdin_sender, "{}", msg)?;
+    writeln!(stdin_sender, "{msg}")?;
+
+    {
+        // 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();
 
-    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)?;
+        // 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::new(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..ee0beddd71 100644
--- a/flake.lock
+++ b/flake.lock
@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,16 +20,32 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1712168706,
-        "narHash": "sha256-XP24tOobf6GGElMd0ux90FEBalUtw6NkBSVh/RlA6ik=",
+        "lastModified": 1767313136,
+        "narHash": "sha256-16KkgfdYqjaeRGBaYsNrhPRRENs0qzkQVUooNHtoy2w=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1487bdea619e4a7a53a4590c475deabb5a9d1bfb",
+        "rev": "ac62194c3917d5f474c1a844b6fd6da2db95077d",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.11",
+        "ref": "nixos-25.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1744536153,
+        "narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }
@@ -37,7 +53,26 @@
     "root": {
       "inputs": {
         "flakeutils": "flakeutils",
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1768272338,
+        "narHash": "sha256-Tg/kL8eKMpZtceDvBDQYU8zowgpr7ucFRnpP/AtfuRM=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "03dda130a8701b08b0347fcaf850a190c53a3c1e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
       }
     },
     "systems": {
diff --git a/flake.nix b/flake.nix
index 9cd483ac66..f51df0902e 100644
--- a/flake.nix
+++ b/flake.nix
@@ -2,17 +2,27 @@
   description = "Wasmer Webassembly runtime";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
-    flakeutils.url = "github:numtide/flake-utils";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    flakeutils = {
+      url = "github:numtide/flake-utils";
+    };
   };
 
-  outputs = { self, nixpkgs, flakeutils }:
+  outputs = { self, nixpkgs, flakeutils, rust-overlay }:
     flakeutils.lib.eachDefaultSystem (system:
       let
         NAME = "wasmer";
 
         pkgs = import nixpkgs {
           inherit system;
+          overlays = [ (import rust-overlay) ];
+        };
+
+        rust-toolchain = pkgs.rust-bin.fromRustupToolchain {
+          channel = pkgs.lib.strings.trim (builtins.readFile ./rust-toolchain);
+          components = [ "clippy" "rustfmt" "rust-analyzer" "rust-src" ];
+          targets = [ "wasm32-unknown-unknown" ];
         };
       in
       rec {
@@ -35,12 +45,19 @@
             openssl
 
             # LLVM and related dependencies
-            llvmPackages_15.libllvm
-            llvmPackages_15.llvm
+            llvmPackages_21.libllvm
+            llvmPackages_21.llvm
+            llvmPackages_21.llvm.dev
+            llvmPackages_21.libclang.dev
             libxml2
             libffi
+            cmake
+            ninja
+            webkitgtk_4_1
+
 
             # Rust tooling
+            rust-toolchain
 
             # Snapshot testing
             # https://github.com/mitsuhiko/insta
@@ -67,11 +84,24 @@
             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
-          ];
+          shellHook = ''
+            export LLVM_SYS_211_PREFIX="${pkgs.llvmPackages_21.llvm.dev}"
+            export LIBCLANG_PATH="${pkgs.llvmPackages_21.libclang.lib}/lib"
+            export PKG_CONFIG_PATH="${pkgs.webkitgtk_4_1.dev}/lib/pkgconfig:$PKG_CONFIG_PATH"
+            export LIBRARY_PATH="${pkgs.llvmPackages_21.compiler-rt-libc}/lib/linux:$LIBRARY_PATH"
+            export LD_LIBRARY_PATH="${pkgs.llvmPackages_21.compiler-rt-libc}/lib/linux:$LD_LIBRARY_PATH"
+            export BINDGEN_EXTRA_CLANG_ARGS="$(
+                  < ${pkgs.llvmPackages_21.stdenv.cc}/nix-support/libc-crt1-cflags
+                ) $(
+                  < ${pkgs.llvmPackages_21.stdenv.cc}/nix-support/libc-cflags
+                ) $(
+                  < ${pkgs.llvmPackages_21.stdenv.cc}/nix-support/cc-cflags
+                ) $(
+                  < ${pkgs.llvmPackages_21.stdenv.cc}/nix-support/libcxx-cxxflags
+                ) \
+                -isystem ${pkgs.glibc.dev}/include \
+                -idirafter ${pkgs.llvmPackages_21.clang}/lib/clang/${pkgs.lib.getVersion pkgs.llvmPackages_21.clang}/include"
+            '';
         };
       }
     );
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index d4a2e6a4a3..059ea44157 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -3,22 +3,22 @@ name = "wasmer-bin-fuzz"
 version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
-edition = "2018"
+edition.workspace = true
 
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
-anyhow = "1"
-wasm-smith = "0.4.4"
-libfuzzer-sys = "0.4.0"
+anyhow.workspace = true
+wasm-smith.workspace = true
+libfuzzer-sys.workspace = true
 wasmer = { path = "../lib/api" }
 wasmer-compiler-cranelift = { path = "../lib/compiler-cranelift", optional = true }
 wasmer-compiler-llvm = { path = "../lib/compiler-llvm", optional = true }
 wasmer-compiler-singlepass = { path = "../lib/compiler-singlepass", optional = true }
 wasmer-compiler = { path = "../lib/compiler", optional = true }
 wasmer-middlewares = { path = "../lib/middlewares" }
-wasmprinter = "0.2"
+wasmprinter.workspace = true
 
 [features]
 cranelift = [ "wasmer-compiler-cranelift" ]
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/fuzz/fuzz_targets/deterministic.rs b/fuzz/fuzz_targets/deterministic.rs
index d2e82125ad..1ec05c2542 100644
--- a/fuzz/fuzz_targets/deterministic.rs
+++ b/fuzz/fuzz_targets/deterministic.rs
@@ -1,37 +1,34 @@
 #![no_main]
 
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
-use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{CompilerConfig, EngineBuilder, Module, Store};
+use libfuzzer_sys::fuzz_target;
+use wasmer::{Module, Store};
 use wasmer_compiler::Engine;
+use wasmer_compiler::{CompilerConfig, EngineBuilder};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_compiler_llvm::LLVM;
 use wasmer_compiler_singlepass::Singlepass;
+mod misc;
+use misc::{SinglePassFuzzModule, ignore_compilation_error, save_wasm_file};
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct NoImportsConfig;
-impl Config for NoImportsConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn allow_start_export(&self) -> bool {
-        false
-    }
-}
-
-fn compile_and_compare(name: &str, engine: Engine, wasm: &[u8]) {
+fn compile_and_compare(name: &str, engine: Engine, wasm_bytes: &[u8]) {
     let store = Store::new(engine);
 
     // compile for first time
-    let module = Module::new(&store, wasm).unwrap();
+    let module = Module::new(&store, wasm_bytes);
+    let module = match module {
+        Ok(m) => m,
+        Err(e) => {
+            if ignore_compilation_error(&e.to_string()) {
+                return;
+            }
+            save_wasm_file(wasm_bytes);
+            panic!("{}", e);
+        }
+    };
     let first = module.serialize().unwrap();
 
     // compile for second time
-    let module = Module::new(&store, wasm).unwrap();
+    let module = Module::new(&store, wasm_bytes).unwrap();
     let second = module.serialize().unwrap();
 
     if first != second {
@@ -39,8 +36,8 @@ fn compile_and_compare(name: &str, engine: Engine, wasm: &[u8]) {
     }
 }
 
-fuzz_target!(|module: ConfiguredModule<NoImportsConfig>| {
-    let wasm_bytes = module.to_bytes();
+fuzz_target!(|module: SinglePassFuzzModule| {
+    let wasm_bytes = module.0.to_bytes();
 
     let mut compiler = Cranelift::default();
     compiler.canonicalize_nans(true);
diff --git a/fuzz/fuzz_targets/equivalence_universal.rs b/fuzz/fuzz_targets/equivalence_universal.rs
index 4db992f314..63ad68d08e 100644
--- a/fuzz/fuzz_targets/equivalence_universal.rs
+++ b/fuzz/fuzz_targets/equivalence_universal.rs
@@ -2,9 +2,10 @@
 #![deny(unused_variables)]
 
 use anyhow::Result;
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
-use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, EngineBuilder, Instance, Module, Store, Val};
+use libfuzzer_sys::fuzz_target;
+use wasmer::{Instance, Module, Store, Value, imports};
+use wasmer_compiler::{CompilerConfig, EngineBuilder};
+
 #[cfg(feature = "cranelift")]
 use wasmer_compiler_cranelift::Cranelift;
 #[cfg(feature = "llvm")]
@@ -12,43 +13,11 @@ use wasmer_compiler_llvm::LLVM;
 #[cfg(feature = "singlepass")]
 use wasmer_compiler_singlepass::Singlepass;
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct ExportedFunctionConfig;
-impl Config for ExportedFunctionConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn min_funcs(&self) -> usize {
-        1
-    }
-    fn min_exports(&self) -> usize {
-        1
-    }
-}
-
-struct WasmSmithModule(ConfiguredModule<ExportedFunctionConfig>);
-impl<'a> arbitrary::Arbitrary<'a> for WasmSmithModule {
-    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        let mut module = ConfiguredModule::<ExportedFunctionConfig>::arbitrary(u)?;
-        module.ensure_termination(100000);
-        Ok(WasmSmithModule(module))
-    }
-}
-impl std::fmt::Debug for WasmSmithModule {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
-    }
-}
-
 #[cfg(feature = "singlepass")]
-fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<(Store, Instance)>> {
     let compiler = Singlepass::default();
-    let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes);
+    let mut store = Store::new(EngineBuilder::new(compiler));
+    let module = Module::new(&store, wasm_bytes);
     let module = match module {
         Ok(m) => m,
         Err(e) => {
@@ -59,36 +28,36 @@ fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
             return Err(e.into());
         }
     };
-    let instance = Instance::new(&module, &imports! {})?;
-    Ok(Some(instance))
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    Ok(Some((store, instance)))
 }
 
 #[cfg(feature = "cranelift")]
-fn maybe_instantiate_cranelift(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+fn maybe_instantiate_cranelift(wasm_bytes: &[u8]) -> Result<Option<(Store, Instance)>> {
     let mut compiler = Cranelift::default();
     compiler.canonicalize_nans(true);
     compiler.enable_verifier();
     let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes)?;
-    let instance = Instance::new(&module, &imports! {})?;
-    Ok(Some(instance))
+    let module = Module::new(&store, wasm_bytes)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    Ok(Some((store, instance)))
 }
 
 #[cfg(feature = "llvm")]
-fn maybe_instantiate_llvm(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+fn maybe_instantiate_llvm(wasm_bytes: &[u8]) -> Result<Option<(Store, Instance)>> {
     let mut compiler = LLVM::default();
     compiler.canonicalize_nans(true);
     compiler.enable_verifier();
-    let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes)?;
-    let instance = Instance::new(&module, &imports! {})?;
-    Ok(Some(instance))
+    let mut store = Store::new(EngineBuilder::new(compiler));
+    let module = Module::new(&store, wasm_bytes)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    Ok(Some((store, instance)))
 }
 
 #[derive(Debug)]
 enum FunctionResult {
-    Error(String),
-    Values(Vec<Val>),
+    Error(()),
+    Values(Vec<Value>),
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -121,8 +90,8 @@ impl PartialEq for FunctionResult {
                         .iter()
                         .zip(other_values.iter())
                         .all(|(x, y)| match (x, y) {
-                            (Val::F32(x), Val::F32(y)) => x.to_bits() == y.to_bits(),
-                            (Val::F64(x), Val::F64(y)) => x.to_bits() == y.to_bits(),
+                            (Value::F32(x), Value::F32(y)) => x.to_bits() == y.to_bits(),
+                            (Value::F64(x), Value::F64(y)) => x.to_bits() == y.to_bits(),
                             _ => x == y,
                         })
             }
@@ -133,8 +102,8 @@ impl PartialEq for FunctionResult {
 
 impl Eq for FunctionResult {}
 
-fn evaluate_instance(instance: Result<Instance>) -> InstanceResult {
-    if let Err(_err) = instance {
+fn evaluate_instance(store_instance: Result<(Store, Instance)>) -> InstanceResult {
+    if let Err(_err) = store_instance {
         /*let mut error_message = format!("{}", err);
         // Remove the stack trace.
         if error_message.starts_with("RuntimeError: unreachable\n") {
@@ -143,13 +112,13 @@ fn evaluate_instance(instance: Result<Instance>) -> InstanceResult {
         InstanceResult::Error(error_message)*/
         InstanceResult::Error("".into())
     } else {
-        let instance = instance.unwrap();
+        let (mut store, instance) = store_instance.unwrap();
         let mut results = vec![];
         for it in instance.exports.iter().functions() {
             let (_, f) = it;
             // TODO: support functions which take params.
-            if f.ty().params().is_empty() {
-                let result = f.call(&[]);
+            if f.ty(&store).params().is_empty() {
+                let result = f.call(&mut store, &[]);
                 let result = if let Ok(values) = result {
                     FunctionResult::Values(values.into())
                 } else {
@@ -158,7 +127,7 @@ fn evaluate_instance(instance: Result<Instance>) -> InstanceResult {
                     let error_message = err.message();
                     FunctionResult::Error(error_message)
                      */
-                    FunctionResult::Error("".into())
+                    FunctionResult::Error(())
                 };
                 results.push(result);
             }
@@ -167,8 +136,8 @@ fn evaluate_instance(instance: Result<Instance>) -> InstanceResult {
     }
 }
 
-fuzz_target!(|module: WasmSmithModule| {
-    let wasm_bytes = module.0.to_bytes();
+fuzz_target!(|module: wasm_smith::Module| {
+    let wasm_bytes = module.to_bytes();
 
     if let Ok(path) = std::env::var("DUMP_TESTCASE") {
         use std::fs::File;
diff --git a/fuzz/fuzz_targets/metering.rs b/fuzz/fuzz_targets/metering.rs
index 6c4f7f89f0..c98c76ce24 100644
--- a/fuzz/fuzz_targets/metering.rs
+++ b/fuzz/fuzz_targets/metering.rs
@@ -1,36 +1,15 @@
 #![no_main]
 
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use libfuzzer_sys::fuzz_target;
+mod misc;
+use misc::{SinglePassFuzzModule, ignore_compilation_error, ignore_runtime_error, save_wasm_file};
 use std::sync::Arc;
-use wasm_smith::{Config, ConfiguredModule};
 use wasmer::wasmparser::Operator;
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer::{Instance, Module, Store, imports};
+use wasmer_compiler::CompilerConfig;
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_middlewares::Metering;
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct NoImportsConfig;
-impl Config for NoImportsConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn allow_start_export(&self) -> bool {
-        false
-    }
-}
-
-#[derive(Arbitrary)]
-struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
-impl std::fmt::Debug for WasmSmithModule {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
-    }
-}
-
 fn cost(operator: &Operator) -> u64 {
     match operator {
         Operator::LocalGet { .. } | Operator::I32Const { .. } => 1,
@@ -39,33 +18,35 @@ fn cost(operator: &Operator) -> u64 {
     }
 }
 
-fuzz_target!(|module: WasmSmithModule| {
+fuzz_target!(|module: SinglePassFuzzModule| {
     let wasm_bytes = module.0.to_bytes();
 
-    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
-        use std::fs::File;
-        use std::io::Write;
-        let mut file = File::create(path).unwrap();
-        file.write_all(&wasm_bytes).unwrap();
-        return;
-    }
-
     let mut compiler = Cranelift::default();
     compiler.canonicalize_nans(true);
     compiler.enable_verifier();
     let metering = Arc::new(Metering::new(10, cost));
     compiler.push_middleware(metering);
     let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes).unwrap();
+
+    let module = Module::new(&store, &wasm_bytes);
+    let module = match module {
+        Ok(m) => m,
+        Err(e) => {
+            if ignore_compilation_error(&e.to_string()) {
+                return;
+            }
+            save_wasm_file(&wasm_bytes);
+            panic!("{}", e);
+        }
+    };
+
     match Instance::new(&mut store, &module, &imports! {}) {
         Ok(_) => {}
         Err(e) => {
-            let error_message = format!("{}", e);
-            if error_message.starts_with("RuntimeError: ")
-                && error_message.contains("out of bounds")
-            {
+            if ignore_runtime_error(&e.to_string()) {
                 return;
             }
+            save_wasm_file(&wasm_bytes);
             panic!("{}", e);
         }
     }
diff --git a/fuzz/fuzz_targets/misc.rs b/fuzz/fuzz_targets/misc.rs
new file mode 100644
index 0000000000..6269359522
--- /dev/null
+++ b/fuzz/fuzz_targets/misc.rs
@@ -0,0 +1,61 @@
+use libfuzzer_sys::arbitrary::Arbitrary;
+
+#[allow(dead_code)]
+pub(crate) struct SinglePassFuzzModule(pub(crate) wasm_smith::Module);
+
+impl Arbitrary<'_> for SinglePassFuzzModule {
+    fn arbitrary(
+        u: &mut libfuzzer_sys::arbitrary::Unstructured,
+    ) -> libfuzzer_sys::arbitrary::Result<Self> {
+        let mut config = wasm_smith::Config::arbitrary(u)?;
+        config.min_imports = 0;
+        config.max_imports = 0;
+        config.max_memory32_bytes = 65535 * 4096;
+        config.min_funcs = 1;
+        config.max_funcs = std::cmp::max(config.min_funcs, config.max_funcs);
+        config.min_exports = 1;
+        config.max_exports = std::cmp::max(config.min_exports, config.max_exports);
+        config.gc_enabled = false;
+        config.exceptions_enabled = false;
+        config.memory64_enabled = false;
+        config.max_memories = 1;
+        config.tail_call_enabled = false;
+        config.simd_enabled = false;
+        config.relaxed_simd_enabled = false;
+        Ok(Self(wasm_smith::Module::new(config, u)?))
+    }
+}
+
+impl std::fmt::Debug for SinglePassFuzzModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn save_wasm_file(data: &[u8]) {
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(&path).unwrap();
+        file.write_all(data).unwrap();
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn ignore_compilation_error(error_message: &str) -> bool {
+    error_message.starts_with("Compilation error: singlepass init_local unimplemented type: V128")
+        || error_message.starts_with("Validation error: constant expression required")
+        || error_message.starts_with("Compilation error: not yet implemented: V128Const")
+        || error_message.starts_with("WebAssembly translation error: Unsupported feature: `ref.null T` that is not a `funcref` or an `externref`: Exn")
+        || error_message.starts_with("WebAssembly translation error: Unsupported feature: unsupported element type in element section: exnref")
+}
+
+#[allow(dead_code)]
+pub(crate) fn ignore_runtime_error(error_message: &str) -> bool {
+    error_message.starts_with("RuntimeError: out of bounds")
+        || error_message.starts_with("RuntimeError: call stack exhausted")
+        || error_message.starts_with("RuntimeError: undefined element: out of bounds")
+        || error_message.starts_with("RuntimeError: unreachable")
+        || error_message.starts_with("Insufficient resources: tables of types other than funcref or externref (ExceptionRef)")
+}
diff --git a/fuzz/fuzz_targets/universal_cranelift.rs b/fuzz/fuzz_targets/universal_cranelift.rs
index 764947f66a..d85a5dfd03 100644
--- a/fuzz/fuzz_targets/universal_cranelift.rs
+++ b/fuzz/fuzz_targets/universal_cranelift.rs
@@ -1,55 +1,66 @@
 #![no_main]
 
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
-use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use libfuzzer_sys::{arbitrary::Arbitrary, fuzz_target};
+mod misc;
+use misc::{ignore_compilation_error, ignore_runtime_error, save_wasm_file};
+use wasmer::{Instance, Module, Store, imports};
+use wasmer_compiler::{CompilerConfig, EngineBuilder};
 use wasmer_compiler_cranelift::Cranelift;
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct NoImportsConfig;
-impl Config for NoImportsConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn allow_start_export(&self) -> bool {
-        false
+struct CraneliftPassFuzzModule(wasm_smith::Module);
+
+impl Arbitrary<'_> for CraneliftPassFuzzModule {
+    fn arbitrary(
+        u: &mut libfuzzer_sys::arbitrary::Unstructured,
+    ) -> libfuzzer_sys::arbitrary::Result<Self> {
+        let mut config = wasm_smith::Config::arbitrary(u)?;
+        config.min_imports = 0;
+        config.max_imports = 0;
+        config.max_memory32_bytes = 65535 * 4096;
+        config.min_funcs = 1;
+        config.max_funcs = std::cmp::max(config.min_funcs, config.max_funcs);
+        config.min_exports = 1;
+        config.max_exports = std::cmp::max(config.min_exports, config.max_exports);
+        config.gc_enabled = false;
+        config.memory64_enabled = false;
+        config.max_memories = 1;
+        config.tail_call_enabled = false;
+        config.simd_enabled = false;
+        config.relaxed_simd_enabled = false;
+        Ok(Self(wasm_smith::Module::new(config, u)?))
     }
 }
-#[derive(Arbitrary)]
-struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
-impl std::fmt::Debug for WasmSmithModule {
+
+impl std::fmt::Debug for CraneliftPassFuzzModule {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
     }
 }
 
-fuzz_target!(|module: WasmSmithModule| {
+fuzz_target!(|module: CraneliftPassFuzzModule| {
     let wasm_bytes = module.0.to_bytes();
 
-    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
-        use std::fs::File;
-        use std::io::Write;
-        let mut file = File::create(path).unwrap();
-        file.write_all(&wasm_bytes).unwrap();
-        return;
-    }
-
     let mut compiler = Cranelift::default();
     compiler.canonicalize_nans(true);
     compiler.enable_verifier();
-    let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes).unwrap();
+    let mut store = Store::new(EngineBuilder::new(compiler));
+    // Save early (and always) as we might hit a crash or a validation error.
+    save_wasm_file(&wasm_bytes);
+    let module = Module::new(&store, &wasm_bytes);
+    let module = match module {
+        Ok(m) => m,
+        Err(e) => {
+            if ignore_compilation_error(&e.to_string()) {
+                return;
+            }
+            panic!("{}", e);
+        }
+    };
+
     match Instance::new(&mut store, &module, &imports! {}) {
         Ok(_) => {}
         Err(e) => {
-            let error_message = format!("{}", e);
-            if error_message.starts_with("RuntimeError: ")
-                && error_message.contains("out of bounds")
-            {
+            if ignore_runtime_error(&e.to_string()) {
                 return;
             }
             panic!("{}", e);
diff --git a/fuzz/fuzz_targets/universal_llvm.rs b/fuzz/fuzz_targets/universal_llvm.rs
index 1f051f8976..40c2af74c0 100644
--- a/fuzz/fuzz_targets/universal_llvm.rs
+++ b/fuzz/fuzz_targets/universal_llvm.rs
@@ -1,55 +1,65 @@
 #![no_main]
 
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
-use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use libfuzzer_sys::{arbitrary::Arbitrary, fuzz_target};
+mod misc;
+use misc::{ignore_compilation_error, ignore_runtime_error, save_wasm_file};
+use wasmer::{Instance, Module, Store, imports};
+use wasmer_compiler::{CompilerConfig, EngineBuilder};
 use wasmer_compiler_llvm::LLVM;
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct NoImportsConfig;
-impl Config for NoImportsConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn allow_start_export(&self) -> bool {
-        false
+struct LLVMPassFuzzModule(wasm_smith::Module);
+
+impl Arbitrary<'_> for LLVMPassFuzzModule {
+    fn arbitrary(
+        u: &mut libfuzzer_sys::arbitrary::Unstructured,
+    ) -> libfuzzer_sys::arbitrary::Result<Self> {
+        let mut config = wasm_smith::Config::arbitrary(u)?;
+        config.min_imports = 0;
+        config.max_imports = 0;
+        config.max_memory32_bytes = 65535 * 4096;
+        config.min_funcs = 1;
+        config.max_funcs = std::cmp::max(config.min_funcs, config.max_funcs);
+        config.min_exports = 1;
+        config.max_exports = std::cmp::max(config.min_exports, config.max_exports);
+        config.gc_enabled = false;
+        config.memory64_enabled = false;
+        config.max_memories = 1;
+        config.tail_call_enabled = false;
+        config.relaxed_simd_enabled = false;
+        Ok(Self(wasm_smith::Module::new(config, u)?))
     }
 }
-#[derive(Arbitrary)]
-struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
-impl std::fmt::Debug for WasmSmithModule {
+
+impl std::fmt::Debug for LLVMPassFuzzModule {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
     }
 }
 
-fuzz_target!(|module: WasmSmithModule| {
+fuzz_target!(|module: LLVMPassFuzzModule| {
     let wasm_bytes = module.0.to_bytes();
 
-    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
-        use std::fs::File;
-        use std::io::Write;
-        let mut file = File::create(path).unwrap();
-        file.write_all(&wasm_bytes).unwrap();
-        return;
-    }
-
     let mut compiler = LLVM::default();
     compiler.canonicalize_nans(true);
     compiler.enable_verifier();
-    let mut store = Store::new(compiler);
-    let module = Module::new(&store, &wasm_bytes).unwrap();
+    let mut store = Store::new(EngineBuilder::new(compiler));
+    // Save early (and always) as we might hit a crash or a validation error in the LLVM library.
+    save_wasm_file(&wasm_bytes);
+
+    let module = match Module::new(&store, &wasm_bytes) {
+        Err(e) => {
+            if ignore_compilation_error(&e.to_string()) {
+                return;
+            }
+            panic!("{}", e);
+        }
+        Ok(module) => module,
+    };
+
     match Instance::new(&mut store, &module, &imports! {}) {
         Ok(_) => {}
         Err(e) => {
-            let error_message = format!("{}", e);
-            if error_message.starts_with("RuntimeError: ")
-                && error_message.contains("out of bounds")
-            {
+            if ignore_runtime_error(&e.to_string()) {
                 return;
             }
             panic!("{}", e);
diff --git a/fuzz/fuzz_targets/universal_singlepass.rs b/fuzz/fuzz_targets/universal_singlepass.rs
index 762f6ece7f..d5534e92d8 100644
--- a/fuzz/fuzz_targets/universal_singlepass.rs
+++ b/fuzz/fuzz_targets/universal_singlepass.rs
@@ -1,63 +1,34 @@
 #![no_main]
 
-use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
-use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, Instance, Module, Store};
+use libfuzzer_sys::fuzz_target;
+mod misc;
+use misc::{SinglePassFuzzModule, ignore_compilation_error, ignore_runtime_error, save_wasm_file};
+use wasmer::{Instance, Module, Store, imports};
+use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_singlepass::Singlepass;
 
-#[derive(Arbitrary, Debug, Default, Copy, Clone)]
-struct NoImportsConfig;
-impl Config for NoImportsConfig {
-    fn max_imports(&self) -> usize {
-        0
-    }
-    fn max_memory_pages(&self) -> u32 {
-        // https://github.com/wasmerio/wasmer/issues/2187
-        65535
-    }
-    fn allow_start_export(&self) -> bool {
-        false
-    }
-}
-#[derive(Arbitrary)]
-struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
-impl std::fmt::Debug for WasmSmithModule {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
-    }
-}
-
-fuzz_target!(|module: WasmSmithModule| {
+fuzz_target!(|module: SinglePassFuzzModule| {
     let wasm_bytes = module.0.to_bytes();
 
-    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
-        use std::fs::File;
-        use std::io::Write;
-        let mut file = File::create(path).unwrap();
-        file.write_all(&wasm_bytes).unwrap();
-        return;
-    }
-
     let compiler = Singlepass::default();
-    let mut store = Store::new(compiler);
+    let mut store = Store::new(EngineBuilder::new(compiler));
+    // Save early (and always) as we might hit a crash or a validation error.
+    save_wasm_file(&wasm_bytes);
     let module = Module::new(&store, &wasm_bytes);
     let module = match module {
         Ok(m) => m,
         Err(e) => {
-            let error_message = format!("{}", e);
-            if error_message.contains("Validation error: invalid result arity: func type returns multiple values") || error_message.contains("Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled") || error_message.contains("multi-value returns not yet implemented") {
+            if ignore_compilation_error(&e.to_string()) {
                 return;
             }
             panic!("{}", e);
         }
     };
+
     match Instance::new(&mut store, &module, &imports! {}) {
         Ok(_) => {}
         Err(e) => {
-            let error_message = format!("{}", e);
-            if error_message.starts_with("RuntimeError: ")
-                && error_message.contains("out of bounds")
-            {
+            if ignore_runtime_error(&e.to_string()) {
                 return;
             }
             panic!("{}", e);
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..c94582b7a5 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,65 +30,83 @@ 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, default-features = true }
 # - Optional shared dependencies.
-wat = { version = "=1.0.71", optional = true }
-rustc-demangle = "0.1"
-shared-buffer = { workspace = true }
+wat = { workspace = true, optional = true }
+rustc-demangle.workspace = true
+shared-buffer.workspace = true
+
+wasmi_c_api_impl = { workspace = true, optional = true, features = [
+	"prefix-symbols",
+] }
+
+loupe = { workspace = true, optional = true, features = [
+	"indexmap",
+	"enable-indexmap",
+] }
+paste.workspace = true
+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 = "=7.0.0", optional = true }
+wasmer-compiler = { path = "../compiler", version = "=7.0.0", optional = true }
+wasmer-derive = { path = "../derive", version = "=7.0.0" }
+wasmer-types = { path = "../types", version = "=7.0.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 }
-
-wasm-bindgen = { version = "0.2.74", optional = true }
-js-sys = { version = "0.3.51", optional = true }
-rusty_jsc = { version = "0.1.0", optional = true }
+wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=7.0.0", optional = true }
+wasmer-compiler-cranelift = { path = "../compiler-cranelift", version = "=7.0.0", optional = true }
+wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=7.0.0", optional = true }
+corosensei = { workspace = true, optional = true }
+futures = { workspace = true, optional = true }
+
+wasm-bindgen = { workspace = true, optional = true }
+js-sys = { workspace = true, optional = true }
+rusty_jsc = { workspace = true, optional = true }
 wasmparser = { workspace = true, default-features = false, optional = true }
 
 # - Mandatory dependencies for `sys` on Windows.
 [target.'cfg(all(not(target_arch = "wasm32"), target_os = "windows"))'.dependencies]
-windows-sys = "0.59"
+windows-sys.workspace = true
 # - 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" }
+wat.workspace = true
+tempfile.workspace = true
+anyhow.workspace = true
+macro-wasmer-universal-test = { version = "7.0.0", path = "./macro-wasmer-universal-test" }
+futures = "0.3"
+tokio = { workspace = true, features = ["full"] }
 
 # 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 = "=7.0.0", default-features = false, features = [
+	"std",
+] }
+wasm-bindgen.workspace = true
+js-sys.workspace = true
+wasmer-derive = { path = "../derive", version = "=7.0.0" }
+wasmer-compiler = { path = "../compiler", version = "=7.0.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.workspace = true
+serde.workspace = true
+target-lexicon.workspace = true
 
 # - Development Dependencies for `js`.
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-wat = "1.0"
-anyhow = "1.0"
-wasm-bindgen-test = "0.3.0"
-macro-wasmer-universal-test = { version = "4.3.7", path = "./macro-wasmer-universal-test" }
+wat.workspace = true
+anyhow.workspace = true
+wasm-bindgen-test.workspace = true
+macro-wasmer-universal-test = { version = "7.0.0", path = "./macro-wasmer-universal-test" }
 
 # Specific to `js`.
 #
@@ -96,58 +120,106 @@ 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"]
+
+headless = []
+
+# Experimental concurrent execution support
+experimental-async = ["dep:futures", "dep:corosensei"]
+
 # - 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_impl"]
+# --- 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.workspace = true
+tar.workspace = true
+ureq = { workspace = true, optional = true }
+which = { workspace = true, optional = true }
+xz = { workspace = true, optional = true }
+zip = { workspace = true, optional = true, features = ["deflate"] }
+
+[target.'cfg(target_env = "musl")'.build-dependencies]
+bindgen = { workspace = true, default-features = false, features = [
+	"static",
+	"logging",
+	"prettyplease",
+] }
+
+[target.'cfg(not(target_env = "musl"))'.build-dependencies]
+bindgen = { workspace = true, default-features = true }
+
 [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..7e462a3fef
--- /dev/null
+++ b/lib/api/build.rs
@@ -0,0 +1,491 @@
+#[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,
+        sync::{LazyLock, Mutex},
+    };
+
+    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_data = ureq::get(WAMR_ZIP)
+            .call()
+            .expect("failed to download wamr")
+            .body_mut()
+            .with_config()
+            .limit(50 * 1024 * 1024) // 50MB
+            .read_to_vec()
+            .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 WAMR_RENAMED: LazyLock<Mutex<Vec<(String, String)>>> =
+        LazyLock::new(|| Mutex::new(Vec::new()));
+
+    #[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);
+                WAMR_RENAMED
+                    .lock()
+                    .expect("cannot lock 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());
+    let bindings_path = out_path.join("wamr_bindings.rs");
+    bindings
+        .write_to_file(&bindings_path)
+        .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();
+
+    let syms: Vec<String> = WAMR_RENAMED.lock().expect("cannot lock 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,
+        sync::{LazyLock, Mutex},
+    };
+
+    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_data = ureq::get(url)
+        .call()
+        .expect("failed to download v8")
+        .body_mut()
+        .with_config()
+        .limit(50 * 1024 * 1024) // 50MB
+        .read_to_vec()
+        .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 WEE8_RENAMED: LazyLock<Mutex<Vec<(String, String)>>> =
+        LazyLock::new(|| Mutex::new(Vec::new()));
+
+    #[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);
+                WEE8_RENAMED
+                    .lock()
+                    .expect("cannot lock 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();
+
+    let syms: Vec<String> = WEE8_RENAMED.lock()
+                        .expect("cannot lock 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());
+    let bindings_path = out_path.join("wasmi_bindings.rs");
+    bindings
+        .write_to_file(&bindings_path)
+        .expect("Couldn't write bindings");
+
+    let original =
+        std::fs::read_to_string(&bindings_path).expect("Failed to read generated wasmi bindings");
+    let mut patched = String::with_capacity(original.len());
+    for line in original.lines() {
+        let trimmed = line.trim_start();
+        let indent_len = line.len() - trimmed.len();
+        let indent = &line[..indent_len];
+        if trimmed.starts_with("extern \"")
+            && trimmed.ends_with('{')
+            && !trimmed.starts_with("unsafe ")
+        {
+            patched.push_str(indent);
+            patched.push_str("unsafe ");
+            patched.push_str(trimmed);
+        } else {
+            patched.push_str(line);
+        }
+        patched.push('\n');
+    }
+    std::fs::write(&bindings_path, patched)
+        .expect("Failed to post-process wasmi bindings for Rust 2024");
+}
+#[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..5a43e597dc 100644
--- a/lib/api/macro-wasmer-universal-test/Cargo.toml
+++ b/lib/api/macro-wasmer-universal-test/Cargo.toml
@@ -1,15 +1,22 @@
 [package]
 name = "macro-wasmer-universal-test"
-version = "4.3.7"
-edition = "2021"
-license = "MIT"
 description = "Universal test macro for wasmer-test"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
 
 [lib]
 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.workspace = true
+syn = { workspace = true, default-features = false, features = [
+    "full",
+    "parsing",
+    "printing",
+    "visit-mut",
+    "clone-impls",
+    "extra-traits",
+    "proc-macro",
+] }
+quote.workspace = true
diff --git a/lib/api/macro-wasmer-universal-test/src/lib.rs b/lib/api/macro-wasmer-universal-test/src/lib.rs
index 9af4a8c042..5b9274a502 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::{
+    Attribute, Signature, Visibility,
+    parse::{Parse, ParseStream},
+};
 
 #[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..2be7a65522
--- /dev/null
+++ b/lib/api/src/backend/js/entities/engine.rs
@@ -0,0 +1,81 @@
+use wasmer_types::{Features, target::Target};
+
+/// 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 {
+        Self
+    }
+}
+
+/// Returns the default engine for the JS engine
+pub(crate) fn default_engine() -> Engine {
+    Engine
+}
+
+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 From<Engine> for crate::Engine {
+    fn from(val: Engine) -> Self {
+        Self {
+            be: crate::BackendEngine::Js(val),
+            id: Self::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..f7b8ca40c1
--- /dev/null
+++ b/lib/api/src/backend/js/entities/exception.rs
@@ -0,0 +1,25 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+
+use super::store::StoreHandle;
+use crate::{
+    AsStoreMut, AsStoreRef, Tag, Value,
+    js::vm::{VMException, VMExceptionRef},
+};
+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 {
+        unimplemented!("Exception handling is not yet supported in js");
+    }
+}
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 69%
rename from lib/api/src/function_env.rs
rename to lib/api/src/backend/js/entities/function/env.rs
index 89c1de7e0d..5b377a326c 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::{
+    StoreMut,
+    js::{store::StoreHandle, vm::VMFunctionEnvironment},
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+};
 
 #[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,14 +55,14 @@ 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()
     }
 
     /// Convert it into a `FunctionEnvMut`
-    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<'_, T>
     where
         T: Any + Send + 'static + Sized,
     {
@@ -102,7 +103,7 @@ pub struct FunctionEnvMut<'a, T: 'a> {
     pub(crate) func_env: FunctionEnv<T>,
 }
 
-impl<'a, T> Debug for FunctionEnvMut<'a, T>
+impl<T> Debug for FunctionEnvMut<'_, T>
 where
     T: Send + Debug + 'static,
 {
@@ -136,7 +137,7 @@ impl<T: Send + 'static> FunctionEnvMut<'_, T> {
     }
 
     /// Borrows a new mutable reference of both the attached Store and host state
-    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+    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
@@ -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 {
+        Self(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 61%
rename from lib/api/src/js/externals/function.rs
rename to lib/api/src/backend/js/entities/function/mod.rs
index 1d588ff9d0..d69b21d424 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::{JsCast, prelude::*};
+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::{
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnv, BackendFunctionEnvMut,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult,
+    NativeWasmType, NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv,
+    WithoutEnv,
+    js::{
+        utils::convert::{AsJs as _, js_value_to_wasmer, wasmer_value_to_js},
+        vm::{VMFuncRef, VMFunctionCallback, function::VMFunction},
+    },
+    vm::{VMExtern, VMExternFunction},
+};
+
+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]));
+                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));
+                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);
@@ -242,7 +233,7 @@ impl Function {
                             break;
                         }
                         Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
-                            return Err(RuntimeError::user(trap))
+                            return Err(RuntimeError::user(trap));
                         }
                         Err(trap) => return Err(RuntimeError::user(trap)),
                     }
@@ -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 {
@@ -288,7 +281,9 @@ impl Function {
 
     #[track_caller]
     fn closures_unsupported_panic() -> ! {
-        unimplemented!("Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840")
+        unimplemented!(
+            "Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840"
+        )
     }
 
     /// Checks whether this `Function` can be used with the given context.
@@ -297,8 +292,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 +322,7 @@ where
         T: Sized,
     {
         Self {
-            address: function.function_callback(),
+            address: function.function_callback(crate::BackendKind::Js).into_js(),
             _phantom: PhantomData,
         }
     }
@@ -345,116 +340,144 @@ 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!(),
+                // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                let func: &Func = unsafe { &*(&() as *const () as *const Func) };
+                let mut store = unsafe { StoreMut::from_raw(store_ptr as *mut _) };
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                    func($(
+                        {
+                            let native = unsafe { NativeWasmTypeInto::from_abi(&mut store, $x) };
+                            FromToNativeWasmType::from_native(native)
                         }
-                    }
-
-                    func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                    ),* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+                        let c_struct = unsafe { result.into_c_struct(&mut store) };
+                        return c_struct;
+                    },
+                    #[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 = unsafe { StoreMut::from_raw(store_ptr as *mut _) };
+                let mut store2 = unsafe { StoreMut::from_raw(store_ptr as *mut _) };
+
+                let result = {
+                    // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                    let func: &Func = unsafe { &*(&() as *const () as *const Func) };
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        let handle: crate::backend::js::store::StoreHandle<crate::backend::js::vm::VMFunctionEnvironment> =
+                          unsafe {
+                              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(), $(
+                            {
+                                let native = unsafe { NativeWasmTypeInto::from_abi(&mut store, $x) };
+                                FromToNativeWasmType::from_native(native)
+                            }
+                        ),* ).into_result()
+                    }))
+                };
+
+                match result {
+                    Ok(Ok(result)) => {
+                        let c_struct = unsafe { result.into_c_struct(&mut store) };
+                        return c_struct;
+                    },
+                    #[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 67%
rename from lib/api/src/js/typed_function.rs
rename to lib/api/src/backend/js/entities/function/typed.rs
index 22cd2bf9c5..229fab787d 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::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+    js::utils::convert::{AsJs, js_value_to_wasmer},
+};
 use js_sys::Array;
 use std::iter::FromIterator;
 use wasm_bindgen::JsValue;
@@ -28,25 +27,31 @@ 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(
-                            &JsValue::UNDEFINED,
-                            unsafe {
-                                &Array::from_iter(params_list.clone()
-                                .into_iter()
-                                .map(|(b, a)| Value::from_raw(store, b, a).as_jsvalue(store)))
-                                }
-                        );
+                        let args_array = unsafe {
+                            Array::from_iter(
+                                params_list
+                                    .clone()
+                                    .into_iter()
+                                    .map(|(b, a)| Value::from_raw(store, b, a).as_jsvalue(store)),
+                            )
+                        };
+                        r = self
+                            .func
+                            .as_js()
+                            .handle
+                            .function
+                            .apply(&JsValue::UNDEFINED, &args_array);
                         let store_mut = store.as_store_mut();
                         if let Some(callback) = store_mut.inner.on_called.take() {
                             match callback(store_mut) {
@@ -66,7 +71,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 +79,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 +88,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!")
+            }
         }
     };
 }
@@ -102,9 +115,15 @@ 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
+);
+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
 );
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..277e92db02 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::{JsValue, prelude::*};
+use wasmer_types::{GlobalType, Mutability, RawValue, Type};
 
-#[derive(Debug, Clone, PartialEq)]
+use crate::{
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
+    js::vm::VMGlobal,
+    vm::{VMExtern, VMExternGlobal},
+};
+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)
         }
@@ -120,20 +127,48 @@ impl Global {
             _ => {
                 return Err(RuntimeError::new(
                     "The type is not yet supported in the JS Global API".to_owned(),
-                ))
+                ));
             }
         };
         self.handle.global.set_value(&new_value);
         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 60%
rename from lib/api/src/js/instance.rs
rename to lib/api/src/backend/js/entities/instance.rs
index 49726418d4..7b3e2217b4 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::{
+    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
+    js::{
+        utils::{convert::AsJs, js_handle::JsHandle},
+        vm::VMInstance,
+    },
+};
+
 #[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in `js`.
 pub struct Instance {
     pub(crate) _handle: JsHandle<VMInstance>,
 }
@@ -24,11 +25,11 @@ impl Instance {
         imports: &Imports,
     ) -> Result<(Self, Exports), InstantiationError> {
         let instance = module
-            .0
+            .as_js()
             .instantiate(&mut store, imports)
-            .map_err(|e| InstantiationError::Start(e))?;
+            .map_err(InstantiationError::Start)?;
 
-        Self::from_module_and_instance(store, &module, instance)
+        Self::from_module_and_instance(store, module, instance)
     }
 
     pub(crate) fn new_by_index(
@@ -61,16 +62,42 @@ impl Instance {
                 let js_export =
                     unsafe { js_sys::Reflect::get(&instance_exports, &name.into()).unwrap() };
                 let extern_ = Extern::from_jsvalue(&mut store, extern_type, &js_export)
-                    .map_err(|e| wasm_bindgen::JsValue::from(e))
+                    .map_err(wasm_bindgen::JsValue::from)
                     .unwrap();
                 Ok((name.to_string(), extern_))
             })
             .collect::<Result<Exports, InstantiationError>>()?;
 
-        let instance = Instance {
+        let instance = Self {
             _handle: JsHandle::new(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..a582580eeb
--- /dev/null
+++ b/lib/api/src/backend/js/entities/memory/buffer.rs
@@ -0,0 +1,82 @@
+use super::Memory;
+use crate::{MemoryAccessError, js::store::StoreObjects};
+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 MemoryBuffer<'_> {
+    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 { 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;
+        let mut slice = unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) };
+        view.subarray(offset as _, end as _).copy_to(slice);
+
+        Ok(slice)
+    }
+
+    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..750bb23f72 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::{
+    AsStoreMut, AsStoreRef, BackendMemory,
+    js::vm::memory::VMMemory,
+    vm::{VMExtern, VMExternMemory},
+};
 
-#[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)
+        Self(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 96%
rename from lib/api/src/js/externals/memory_view.rs
rename to lib/api/src/backend/js/entities/memory/view.rs
index f4830add65..628af3958e 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.
 ///
@@ -92,9 +91,9 @@ impl<'a> MemoryView<'a> {
     /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
     /// # let mut store = Store::default();
     /// #
-    /// let m = Memory::new(&store, MemoryType::new(1, None, false)).unwrap();
+    /// let m = Memory::new(& mut store, MemoryType::new(1, None, false)).unwrap();
     ///
-    /// assert_eq!(m.size(), Pages(1));
+    /// assert_eq!(m.size(&store), Pages(1));
     /// ```
     pub fn size(&self) -> Pages {
         Bytes(self.size as usize).try_into().unwrap()
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 80%
rename from lib/api/src/js/module.rs
rename to lib/api/src/backend/js/entities/module.rs
index 61866abcf5..38d83bce46 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::{JsValue, prelude::*};
 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::{
+    AsEngineRef, AsStoreMut, BackendModule, Extern, Imports, InstantiationError, IntoBytes,
+    RuntimeError,
+    js::{
+        utils::{convert::AsJs as _, js_handle::JsHandle},
+        vm::VMInstance,
+    },
 };
 
 /// 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 {}
 
@@ -73,10 +71,15 @@ impl Module {
         _engine: &impl AsEngineRef,
         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())))?;
-        Ok(Self::from_js_module(module, binary))
+        let js_bytes = unsafe { Uint8Array::view(binary) };
+        let module = WebAssembly::Module::new(&js_bytes.into()).map_err(|e| {
+            CompileError::Validate(
+                e.as_string()
+                    .unwrap_or("Unknown validation error".to_string())
+                    .to_string(),
+            )
+        })?;
+        Ok(unsafe { Self::from_js_module(module, binary) })
     }
 
     /// Creates a new WebAssembly module skipping any kind of validation from a javascript module
@@ -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 {
@@ -202,8 +205,8 @@ impl Module {
             // in case the import is not found, the JS Wasm VM will handle
             // the error for us, so we don't need to handle it
         }
-        Ok(WebAssembly::Instance::new(&self.module, &imports_object)
-            .map_err(|e: JsValue| -> RuntimeError { e.into() })?)
+        WebAssembly::Instance::new(&self.module, &imports_object)
+            .map_err(|e: JsValue| -> RuntimeError { e.into() })
     }
 
     pub fn name(&self) -> Option<&str> {
@@ -254,7 +257,7 @@ impl Module {
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let bytes = std::fs::read(path.as_ref())?;
-        Self::deserialize(engine, bytes)
+        unsafe { Self::deserialize(engine, bytes) }
     }
 
     pub unsafe fn deserialize_from_file(
@@ -262,7 +265,7 @@ impl Module {
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let bytes = std::fs::read(path.as_ref())?;
-        Self::deserialize(engine, bytes)
+        unsafe { Self::deserialize(engine, bytes) }
     }
 
     pub fn set_name(&mut self, name: &str) -> bool {
@@ -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,16 +369,22 @@ 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));
+                return Err(format!(
+                    "The provided type hint for the export {} is {} which doesn't match the expected kind: {}",
+                    i,
+                    kind.as_str(),
+                    expected_kind
+                ));
             }
         }
         self.type_hints = Some(type_hints);
         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 +438,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 {
@@ -450,8 +464,8 @@ impl Module {
 
 impl From<WebAssembly::Module> for Module {
     #[track_caller]
-    fn from(module: WebAssembly::Module) -> Module {
-        Module {
+    fn from(module: WebAssembly::Module) -> Self {
+        Self {
             module: JsHandle::new(module),
             name: None,
             type_hints: None,
@@ -462,18 +476,49 @@ 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())) }
+    fn from((module, binary): (WebAssembly::Module, T)) -> Self {
+        unsafe {
+            Self(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())
+    fn from(module: WebAssembly::Module) -> Self {
+        Self(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(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 &mut self.0 {
+            BackendModule::Js(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..187deda4e5
--- /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::{StoreObjects, obj::StoreObject};
+
+/// 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..ff840f187b
--- /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..e376facc89
--- /dev/null
+++ b/lib/api/src/backend/js/entities/table.rs
@@ -0,0 +1,193 @@
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+    js::vm::{VMFunction, VMTable},
+    vm::{VMExtern, VMExternTable},
+};
+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 Ok(func) = self.handle.table.get(index) {
+            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(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 &mut self.0 {
+            BackendTable::Js(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(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(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..7456d26ea0
--- /dev/null
+++ b/lib/api/src/backend/js/entities/tag.rs
@@ -0,0 +1,87 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTag, TagKind,
+    js::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+};
+
+#[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
+            .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(crate) 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(crate) 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(crate) 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 68%
rename from lib/api/src/js/trap.rs
rename to lib/api/src/backend/js/error.rs
index 23a002e066..7b5e28fb75 100644
--- a/lib/api/src/js/trap.rs
+++ b/lib/api/src/backend/js/error.rs
@@ -1,12 +1,12 @@
-use std::{
-    error::Error,
-    fmt::{self, Display},
-};
+use std::error::Error;
 
 use js_sys::Reflect;
-use wasm_bindgen::{prelude::*, JsValue};
+use wasm_bindgen::{JsValue, prelude::*};
 
-use crate::RuntimeError;
+use crate::{
+    RuntimeError,
+    js::{exception::Exception, vm::VMExceptionRef},
+};
 
 #[derive(Debug)]
 enum InnerTrap {
@@ -53,6 +53,16 @@ impl Trap {
             _ => false,
         }
     }
+
+    /// Returns true if the `Trap` is an exception
+    pub fn is_exception(&self) -> bool {
+        false
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        None
+    }
 }
 
 #[wasm_bindgen]
@@ -71,8 +81,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}"),
@@ -84,13 +94,13 @@ impl From<JsValue> for RuntimeError {
     fn from(value: JsValue) -> Self {
         // We try to downcast the error and see if it's an instance of Trap
         // instead, so we don't need to re-wrap it.
-        if let Some(obj) = value.dyn_ref() {
-            if let Some(trap) = downcast_from_ptr(obj) {
-                return trap.into();
-            }
+        if let Some(obj) = value.dyn_ref()
+            && let Some(trap) = downcast_from_ptr(obj)
+        {
+            return trap.into();
         }
 
-        RuntimeError::from(Trap {
+        Self::from(Trap {
             inner: InnerTrap::Js(value.into()),
         })
     }
@@ -114,10 +124,7 @@ fn downcast_from_ptr(value: &JsValue) -> Option<Trap> {
         .and_then(|v: JsValue| v.dyn_into())
         .ok();
 
-    if marker_func.is_none() {
-        // We couldn't find the marker, so it's something else.
-        return None;
-    }
+    marker_func.as_ref()?;
 
     // Safety: The marker function exists, therefore it's safe to convert back
     // to a Trap.
@@ -153,27 +160,63 @@ impl From<JsValue> for JsTrap {
     fn from(value: JsValue) -> Self {
         // Let's try some easy special cases first
         if let Some(error) = value.dyn_ref::<js_sys::Error>() {
-            return JsTrap::Message(error.message().into());
+            return Self::Message(error.message().into());
         }
 
         if let Some(s) = value.as_string() {
-            return JsTrap::Message(s);
+            return Self::Message(s);
         }
 
         // Otherwise, we'll try to stringify the error and hope for the best
         if let Some(obj) = value.dyn_ref::<js_sys::Object>() {
-            return JsTrap::Message(obj.to_string().into());
+            return Self::Message(obj.to_string().into());
         }
 
-        JsTrap::Unknown
+        Self::Unknown
     }
 }
 
-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"),
+            Self::Message(m) => write!(f, "{m}"),
+            Self::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();
+        }
+
+        Self::new_from_source(crate::BackendTrap::Js(trap), vec![], None)
+    }
+}
+
+impl From<RuntimeError> for wasm_bindgen::JsValue {
+    fn from(value: RuntimeError) -> Self {
+        Self::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 70%
rename from lib/api/src/js/as_js.rs
rename to lib/api/src/backend/js/utils/convert.rs
index 5068c8b127..a8c00724f7 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::{
+    Extern, Function, Global, Memory, Table, Tag, Type,
+    imports::Imports,
+    instance::Instance,
+    js::{
+        instance::Instance as JsInstance,
+        vm::{VMFunction, VMGlobal, VMMemory, VMTable, VMTag},
+    },
+    store::{AsStoreMut, AsStoreRef},
+    value::Value,
+};
+
 /// 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(
@@ -211,9 +236,9 @@ impl AsJs for Instance {
     ) -> Result<Self, JsError> {
         let js_instance: js_sys::WebAssembly::Instance = value.clone().into();
         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,
+            .map_err(|e| JsError::new(&format!("Can't get the instance: {e:?}")))?;
+        Ok(Self {
+            _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(
@@ -233,14 +258,13 @@ impl AsJs for Memory {
         value: &JsValue,
     ) -> Result<Self, JsError> {
         if let Some(memory) = value.dyn_ref::<JsMemory>() {
-            Ok(Memory::from_vm_extern(
+            Ok(Self::from_vm_extern(
                 store,
-                VMMemory::new(memory.clone(), memory_type.clone()),
+                crate::vm::VMExternMemory::Js(VMMemory::new(memory.clone(), *memory_type)),
             ))
         } else {
             Err(JsError::new(&format!(
-                "Extern expect to be of type Memory, but received {:?}",
-                value
+                "Extern expect to be of type Memory, but received {value:?}",
             )))
         }
     }
@@ -250,7 +274,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(
@@ -259,17 +283,43 @@ impl AsJs for Function {
         value: &JsValue,
     ) -> Result<Self, JsError> {
         if value.is_instance_of::<JsFunction>() {
-            Ok(Function::from_vm_extern(
+            Ok(Self::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!(
+                "Extern expect to be of type Function, but received {value:?}",
+            )))
+        }
+    }
+}
+
+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(Self::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 Function, but received {:?}",
-                value
+                "Extern expect to be of type Tag, but received {value:?}",
             )))
         }
     }
@@ -279,7 +329,7 @@ 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(
@@ -288,17 +338,16 @@ impl AsJs for Global {
         value: &JsValue,
     ) -> Result<Self, JsError> {
         if value.is_instance_of::<JsGlobal>() {
-            Ok(Global::from_vm_extern(
+            Ok(Self::from_vm_extern(
                 store,
-                VMGlobal::new(
+                crate::vm::VMExternGlobal::Js(VMGlobal::new(
                     value.clone().unchecked_into::<JsGlobal>(),
-                    global_type.clone(),
-                ),
+                    *global_type,
+                )),
             ))
         } else {
             Err(JsError::new(&format!(
-                "Extern expect to be of type Global, but received {:?}",
-                value
+                "Extern expect to be of type Global, but received {value:?}",
             )))
         }
     }
@@ -308,7 +357,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(
@@ -317,17 +366,16 @@ impl AsJs for Table {
         value: &JsValue,
     ) -> Result<Self, JsError> {
         if value.is_instance_of::<JsTable>() {
-            Ok(Table::from_vm_extern(
+            Ok(Self::from_vm_extern(
                 store,
-                VMTable::new(
+                crate::vm::VMExternTable::Js(VMTable::new(
                     value.clone().unchecked_into::<JsTable>(),
-                    table_type.clone(),
-                ),
+                    *table_type,
+                )),
             ))
         } else {
             Err(JsError::new(&format!(
-                "Extern expect to be of type Table, but received {:?}",
-                value
+                "Extern expect to be of type Table, but received {value:?}",
             )))
         }
     }
diff --git a/lib/api/src/js/js_handle.rs b/lib/api/src/backend/js/utils/js_handle.rs
similarity index 96%
rename from lib/api/src/js/js_handle.rs
rename to lib/api/src/backend/js/utils/js_handle.rs
index 043cc1eb28..c9ff1be1c9 100644
--- a/lib/api/src/js/js_handle.rs
+++ b/lib/api/src/backend/js/utils/js_handle.rs
@@ -19,7 +19,7 @@ pub(crate) struct JsHandle<T> {
 impl<T> JsHandle<T> {
     #[track_caller]
     pub fn new(value: T) -> Self {
-        JsHandle {
+        Self {
             value,
             integrity: IntegrityCheck::new(std::any::type_name::<T>()),
         }
@@ -34,7 +34,7 @@ impl<T> JsHandle<T> {
 
 impl<T: PartialEq> PartialEq for JsHandle<T> {
     fn eq(&self, other: &Self) -> bool {
-        let JsHandle {
+        let Self {
             value,
             integrity: _,
         } = self;
@@ -48,11 +48,11 @@ impl<T: Eq> Eq for JsHandle<T> {}
 impl<T> From<T> for JsHandle<T> {
     #[track_caller]
     fn from(value: T) -> Self {
-        JsHandle::new(value)
+        Self::new(value)
     }
 }
 
-impl<T: Into<JsValue>> From<JsHandle<T>> for JsValue {
+impl<T: Into<Self>> From<JsHandle<T>> for JsValue {
     fn from(value: JsHandle<T>) -> Self {
         value.into_inner().into()
     }
@@ -120,7 +120,7 @@ mod integrity_check {
     impl IntegrityCheck {
         #[track_caller]
         pub(crate) fn new(type_name: &'static str) -> Self {
-            IntegrityCheck {
+            Self {
                 original_thread: super::current_thread_id(),
                 created: Location::caller(),
                 type_name,
@@ -133,7 +133,7 @@ mod integrity_check {
             let current_thread = super::current_thread_id();
 
             if current_thread != self.original_thread {
-                let IntegrityCheck {
+                let Self {
                     original_thread,
                     created,
                     type_name,
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..4a15d8ea91
--- /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<Self, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Self, 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,
+        })
+    }
+}
+
+impl From<VMMemory> for JsValue {
+    fn from(value: VMMemory) -> Self {
+        Self::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 63%
rename from lib/api/src/jsc/engine.rs
rename to lib/api/src/backend/jsc/entities/engine.rs
index adbf7a33cd..11e735f3a1 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::{Features, target::Target};
+
+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,46 +80,46 @@ 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()
+        self.engine().jsc()
     }
 }
 
-impl JSC for crate::store::StoreMut<'_> {
+impl IntoJSC for crate::store::StoreMut<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().jsc()
+        self.engine().jsc()
     }
 }
 
-impl JSC for crate::Store {
+impl IntoJSC for crate::Store {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().jsc()
+        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 From<Engine> for crate::Engine {
+    fn from(engine: Engine) -> Self {
+        Self {
+            be: crate::BackendEngine::Jsc(engine),
+            id: Self::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..beb8949c98
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/exception.rs
@@ -0,0 +1,27 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, Tag, Value,
+    jsc::vm::{VMException, VMExceptionRef},
+};
+
+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 {
+        unimplemented!("Exception handling is not yet supported in jsc");
+    }
+}
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..88739f08a5
--- /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::{
+    StoreMut,
+    jsc::{store::StoreHandle, vm::VMFunctionEnvironment},
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+};
+
+#[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<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, 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<'a>(&'a mut self) -> (&'a mut T, StoreMut<'a>) {
+        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 {
+        Self(crate::BackendFunctionEnvMut::Jsc(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        Self(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..afe36b214a
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/function/mod.rs
@@ -0,0 +1,604 @@
+pub(crate) mod env;
+pub(crate) mod typed;
+
+use rusty_jsc::{
+    JSContext, JSObject, JSObjectCallAsFunctionCallback, JSValue, callback, callback_closure,
+};
+use std::marker::PhantomData;
+use std::panic::{self, AssertUnwindSafe};
+use wasmer_types::{FunctionType, RawValue};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, FromToNativeWasmType,
+    FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+    jsc::{
+        store::{InternalStoreHandle, StoreHandle},
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
+        vm::{VMFuncRef, VMFunction, VMFunctionEnvironment},
+    },
+    vm::VMExtern,
+};
+
+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(&store)),
+                _ => Ok(JSObject::new_array(
+                    &ctx,
+                    &results
+                        .into_iter()
+                        .map(|result| result.as_jsc_value(&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)]
+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 = unsafe { &*(&() 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 = unsafe { 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( unsafe {
+                        $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 = unsafe { result.into_array(&mut store) };
+                                let val = unsafe { Value::from_raw(&mut store, ty, arr.as_mut()[0]) };
+                                let value: JSValue = val.as_jsc_value(&store);
+                                Ok(value)
+                            }
+                            _n => {
+                                let mut arr = unsafe { result.into_array(&mut store) };
+                                let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                    let raw = arr.as_mut()[i];
+                                    let value = unsafe { Value::from_raw(&mut store, *ret_type, raw) };
+                                    value.as_jsc_value(&mut store)
+                                }).collect::<Vec<_>>();
+                                Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                            }
+                        }
+                    },
+                    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 = unsafe { &*(&() 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 = unsafe { StoreMut::from_raw(store_ptr as usize as *mut _) };
+
+                let handle_index = arguments[0].to_number(&ctx).unwrap() as usize;
+                let handle: StoreHandle<VMFunctionEnvironment> = unsafe {
+                    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 = unsafe { StoreMut::from_raw(store_ptr as usize as *mut _) };
+                    func(
+                        BackendFunctionEnvMut::Jsc(env).into(),
+                        $( FromToNativeWasmType::from_native( unsafe {
+                            $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 = unsafe { result.into_array(&mut store) };
+                                // Value::from_raw(&store, ty, arr[0])
+                                let val = unsafe { 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 = unsafe { result.into_array(&mut store) };
+                                let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                    let raw = arr.as_mut()[i];
+                                    let value = unsafe { Value::from_raw(&mut store, *ret_type, raw) };
+                                    value.as_jsc_value(&mut store)
+                                }).collect::<Vec<_>>();
+                                Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                            }
+                        }
+                    },
+                    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)))
+                    },
+                }
+
+            }
+
+            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 73%
rename from lib/api/src/jsc/typed_function.rs
rename to lib/api/src/backend/jsc/entities/function/typed.rs
index ff3cf39461..b0d3c3026f 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::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+    backend::jsc::{
+        engine::IntoJSC,
+        error::Trap,
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
+    },
+};
+
+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)
                     } ),* ]
                 };
 
@@ -47,7 +49,7 @@ macro_rules! impl_native_traits {
 
                 let 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 _)).unwrap();
+                global.set_property(context, "__store_ptr".to_string(), JSValue::number(context, store_ptr as _)).unwrap();
 
                 let results = {
                     let mut r;
@@ -56,9 +58,9 @@ 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,
+                                context,
                                 None,
                                 &params_list,
                             );
@@ -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,20 +92,20 @@ 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 => {
-                        if !results.is_array(&context) {
+                        if !results.is_array(context) {
                             panic!("Expected results to be an array.")
                         }
-                        let results = results.to_object(&context).unwrap();
+                        let results = results.to_object(context).unwrap();
                         for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
                             let store_mut = store.as_store_mut();
                             let context = store_mut.jsc().context();
-                            let ret = results.get_property_at_index(&context, i as _).unwrap();
+                            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!")
+            }
         }
     };
 }
@@ -131,9 +141,15 @@ 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
+);
+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
 );
diff --git a/lib/api/src/backend/jsc/entities/global.rs b/lib/api/src/backend/jsc/entities/global.rs
new file mode 100644
index 0000000000..3b55df5694
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/global.rs
@@ -0,0 +1,150 @@
+use rusty_jsc::{JSObject, JSValue};
+use wasmer_types::{GlobalType, Mutability, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
+    jsc::{
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
+        vm::VMGlobal,
+    },
+    vm::VMExtern,
+};
+
+use super::store::StoreObject;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+// 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 {
+        VMExtern::Jsc(crate::backend::jsc::vm::VMExtern::Global(
+            self.handle.clone(),
+        ))
+    }
+
+    /// 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> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new("cross-`Store` values are not supported"));
+        }
+        let global_ty = GlobalType {
+            mutability,
+            ty: val.ty(),
+        };
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+
+        let mut descriptor = JSObject::new(context);
+        let type_str = match val.ty() {
+            Type::I32 => "i32",
+            Type::I64 => "i64",
+            Type::F32 => "f32",
+            Type::F64 => "f64",
+            ty => unimplemented!(
+                "The type: {:?} is not yet supported in the JS Global API",
+                ty
+            ),
+        };
+        // This is the value type as string, even though is incorrectly called "value"
+        // in the JS API.
+        descriptor.set_property(
+            context,
+            "value".to_string(),
+            JSValue::string(context, type_str.to_string()),
+        );
+        descriptor.set_property(
+            context,
+            "mutable".to_string(),
+            JSValue::boolean(context, mutability.is_mutable()),
+        );
+
+        let value: JSValue = val.as_jsc_value(&store_mut);
+        let js_global = engine
+            .as_jsc()
+            .wasm_global_type()
+            .construct(context, &[descriptor.to_jsvalue(), value])
+            .map_err(<JSValue as Into<RuntimeError>>::into)?;
+        let vm_global = VMGlobal::new(js_global, global_ty);
+        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 {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        let value = self
+            .handle
+            .global
+            .get_property(context, "value".to_string());
+        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_jsc_value(&store_mut);
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        self.handle
+            .global
+            .set_property(context, "value".to_string(), new_value)
+            .map_err(<JSValue as Into<RuntimeError>>::into)
+    }
+
+    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 53%
rename from lib/api/src/jsc/instance.rs
rename to lib/api/src/backend/jsc/entities/instance.rs
index 614eb76e75..7e46e9a798 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::{
+    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
+};
+
+use super::engine::IntoJSC;
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct Instance {
@@ -18,19 +15,21 @@ pub struct Instance {
 // unsafe impl Send for Instance {}
 
 impl Instance {
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new(
         mut store: &mut impl AsStoreMut,
         module: &Module,
         imports: &Imports,
     ) -> Result<(Self, Exports), InstantiationError> {
         let instance = module
-            .0
+            .as_jsc()
             .instantiate(&mut store, imports)
-            .map_err(|e| InstantiationError::Start(e))?;
+            .map_err(InstantiationError::Start)?;
 
-        Self::from_module_and_instance(store, &module, instance)
+        Self::from_module_and_instance(store, module, instance)
     }
 
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new_by_index(
         store: &mut impl AsStoreMut,
         module: &Module,
@@ -43,6 +42,7 @@ impl Instance {
         Self::new(store, module, &imports)
     }
 
+    #[allow(clippy::result_large_err)]
     pub(crate) fn from_module_and_instance(
         mut store: &mut impl AsStoreMut,
         module: &Module,
@@ -52,8 +52,8 @@ impl Instance {
         let context = engine.jsc().context();
 
         let mut instance_exports = instance
-            .get_property(&context, "exports".to_string())
-            .to_object(&context)
+            .get_property(context, "exports".to_string())
+            .to_object(context)
             .unwrap();
 
         let exports_ty = module.exports().collect::<Vec<_>>();
@@ -66,8 +66,8 @@ impl Instance {
                 let context = store.jsc().context();
                 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 js_export = instance_exports.get_property(context, name.to_string());
+                let extern_ = Extern::from_jsc_value(&mut store, extern_type, &js_export).unwrap();
                 Ok((name.to_string(), extern_))
             })
             .collect::<Result<Exports, InstantiationError>>()?;
@@ -75,3 +75,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..ef47d23ab6
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/memory/buffer.rs
@@ -0,0 +1,147 @@
+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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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>();
+        }
+    }
+
+    unsafe {
+        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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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>();
+        }
+    }
+
+    unsafe {
+        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..04b974b667
--- /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::{AsStoreMut, AsStoreRef, BackendMemory, jsc::vm::VMMemory, vm::VMExtern};
+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 91%
rename from lib/api/src/jsc/externals/memory_view.rs
rename to lib/api/src/backend/jsc/entities/memory/view.rs
index bb891293f2..686ebc7005 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,15 +25,15 @@ 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())
-            .to_object(&context)
+            .get_property(context, "buffer".to_string())
+            .to_object(context)
             .unwrap();
-        let typed_buffer = JSObject::create_typed_array_from_buffer(&context, buffer).unwrap();
+        let typed_buffer = JSObject::create_typed_array_from_buffer(context, buffer).unwrap();
 
-        let mut buffer_data = typed_buffer.get_typed_array_buffer(&context).unwrap();
+        let mut buffer_data = typed_buffer.get_typed_array_buffer(context).unwrap();
         // println!("BUFFER DATA {}", buffer_data.to_string(&context));
 
         // let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();
@@ -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 {
@@ -76,7 +71,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.data_unchecked_mut()
+        unsafe { std::slice::from_raw_parts(self.buffer.base, self.buffer.len) }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -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)
+        unsafe { 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 58%
rename from lib/api/src/jsc/module.rs
rename to lib/api/src/backend/jsc/entities/module.rs
index 08146f4ad7..4d7e2f1136 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::{
+    AsEngineRef, AsStoreMut, AsStoreRef, BackendModule, Imports, InstantiationError, IntoBytes,
+    RuntimeError,
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
 };
 
+use super::engine::IntoJSC;
+
 #[derive(Clone, PartialEq, Eq)]
 pub struct Module {
     module: JSObject,
@@ -53,14 +51,14 @@ impl Module {
         let engine = engine.as_engine_ref();
         let jsc = engine.jsc();
         let context = jsc.context();
-        let bytes = JSObject::create_typed_array_with_bytes(&context, &mut binary).unwrap();
+        let bytes = JSObject::create_typed_array_with_bytes(context, &mut binary).unwrap();
         let module_type = jsc.wasm_module_type();
         let global_wasm = jsc.global_wasm();
         let module = module_type
-            .construct(&context, &[bytes.to_jsvalue()])
-            .map_err(|e| CompileError::Validate(format!("{}", e.to_string(&context).unwrap())))?;
+            .construct(context, &[bytes.to_jsvalue()])
+            .map_err(|e| CompileError::Validate(format!("{}", e.to_string(context).unwrap())))?;
 
-        Ok(Self::from_js_module(module, binary))
+        Ok(unsafe { Self::from_js_module(module, binary) })
     }
 
     /// Creates a new WebAssembly module skipping any kind of validation from a javascript module
@@ -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;
 
@@ -86,22 +84,24 @@ impl Module {
         let jsc = engine.jsc();
         let context = jsc.context();
         let mut binary = binary.to_vec();
-        let bytes = JSObject::create_typed_array_with_bytes(&context, &mut binary).unwrap();
+        let bytes = JSObject::create_typed_array_with_bytes(context, &mut binary).unwrap();
 
         let global_wasm = jsc.global_wasm();
         let validate_type = jsc.wasm_validate_type();
 
-        match validate_type.call(&context, Some(&global_wasm), &[bytes.to_jsvalue()]) {
+        match validate_type.call(context, Some(global_wasm), &[bytes.to_jsvalue()]) {
             Ok(val) => {
-                if val.to_bool(&context) {
+                if val.to_bool(context) {
                     Ok(())
                 } else {
-                    Err(CompileError::Validate(format!("Not a valid wasm binary")))
+                    Err(CompileError::Validate(
+                        "Not a valid wasm binary".to_string(),
+                    ))
                 }
             }
             Err(e) => Err(CompileError::Validate(format!(
                 "Error while validating: {}",
-                e.to_string(&context).unwrap()
+                e.to_string(context).unwrap()
             ))),
         }
     }
@@ -116,38 +116,47 @@ impl Module {
             .into_iter()
             .any(|(_, import)| !import.is_from_store(store))
         {
-            return Err(RuntimeError::user(Box::new(
-                InstantiationError::DifferentStores,
-            )));
+            #[cfg(feature = "std")]
+            {
+                return Err(RuntimeError::user(Box::new(
+                    InstantiationError::DifferentStores,
+                )));
+            }
+            #[cfg(not(feature = "std"))]
+            {
+                return Err(RuntimeError::new(
+                    "cannot mix imports from different stores",
+                ));
+            }
         }
 
         let store = store.as_store_mut();
         let context = store.jsc().context();
 
-        let mut imports_object = JSObject::new(&context);
+        let mut imports_object = JSObject::new(context);
         for import_type in self.imports() {
             let resolved_import = imports.get_export(import_type.module(), import_type.name());
             if let Some(import) = resolved_import {
-                let val = imports_object.get_property(&context, import_type.module().to_string());
-                if !val.is_undefined(&context) {
+                let val = imports_object.get_property(context, import_type.module().to_string());
+                if !val.is_undefined(context) {
                     // If the namespace is already set
-                    let mut obj_val = val.to_object(&context).unwrap();
+                    let mut obj_val = val.to_object(context).unwrap();
                     obj_val.set_property(
-                        &context,
+                        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
-                    let mut import_namespace = JSObject::new(&context);
+                    let mut import_namespace = JSObject::new(context);
                     import_namespace.set_property(
-                        &context,
+                        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(
-                            &context,
+                            context,
                             import_type.module().to_string(),
                             import_namespace.to_jsvalue(),
                         )
@@ -165,11 +174,12 @@ impl Module {
         }
 
         let instance_type = store.jsc().wasm_instance_type();
-        let instance = instance_type.construct(
-            &context,
-            &[self.module.to_jsvalue(), imports_object.to_jsvalue()],
-        );
-        Ok(instance.map_err(|e: JSValue| -> RuntimeError { e.into() })?)
+        instance_type
+            .construct(
+                context,
+                &[self.module.to_jsvalue(), imports_object.to_jsvalue()],
+            )
+            .map_err(|e: JSValue| -> RuntimeError { e.into() })
     }
 
     pub fn name(&self) -> Option<&str> {
@@ -177,24 +187,23 @@ impl Module {
     }
 
     pub fn serialize(&self) -> Result<Bytes, SerializeError> {
-        return self.raw_bytes.clone().ok_or(SerializeError::Generic(
+        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)
+        unsafe { 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));
+        Self::from_binary(engine, &bytes.into_bytes()).map_err(DeserializeError::Compiler)
     }
 
     pub unsafe fn deserialize_from_file_unchecked(
@@ -202,7 +211,7 @@ impl Module {
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let bytes = std::fs::read(path.as_ref())?;
-        Self::deserialize_unchecked(engine, bytes)
+        unsafe { Self::deserialize_unchecked(engine, bytes) }
     }
 
     pub unsafe fn deserialize_from_file(
@@ -210,7 +219,7 @@ impl Module {
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let bytes = std::fs::read(path.as_ref())?;
-        Self::deserialize(engine, bytes)
+        unsafe { Self::deserialize(engine, bytes) }
     }
 
     pub fn set_name(&mut self, name: &str) -> bool {
@@ -218,15 +227,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 +247,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..e840a257a2
--- /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<'a>(&'a self) -> core::slice::Iter<'a, 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/backend/jsc/entities/table.rs b/lib/api/src/backend/jsc/entities/table.rs
new file mode 100644
index 0000000000..7f3d71f2bb
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/table.rs
@@ -0,0 +1,202 @@
+use rusty_jsc::{JSObject, JSValue};
+use wasmer_types::TableType;
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+    jsc::vm::{VMExternTable, VMTable},
+    vm::VMExtern,
+};
+
+#[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: &JSObject) -> Result<(), RuntimeError> {
+    unimplemented!();
+    // table.table.set(item_index, item).map_err(|e| e.into())
+}
+
+fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<JSObject, RuntimeError> {
+    unimplemented!();
+}
+
+impl Table {
+    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 context = engine.as_jsc().context();
+
+        let mut descriptor = JSObject::new(context);
+        descriptor.set_property(
+            context,
+            "initial".to_string(),
+            JSValue::number(context, ty.minimum.into()),
+        );
+        if let Some(max) = ty.maximum {
+            descriptor.set_property(
+                context,
+                "maximum".to_string(),
+                JSValue::number(context, max.into()),
+            );
+        }
+        descriptor.set_property(
+            context,
+            "element".to_string(),
+            JSValue::string(context, "anyfunc".to_string()),
+        );
+
+        let js_table = engine
+            .as_jsc()
+            .wasm_table_type()
+            .construct(context, &[descriptor.to_jsvalue()])
+            .map_err(<JSValue as Into<RuntimeError>>::into)?;
+        let vm_table = VMTable::new(js_table, ty);
+        Ok(Self { handle: vm_table })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Jsc(crate::backend::jsc::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> {
+        unimplemented!();
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!();
+        // let item = get_function(store, val)?;
+        // set_table_item(&self.handle, index, &item)
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        let store_mut = store.as_store_ref();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        self.handle
+            .table
+            .get_property(context, "length".to_string())
+            .to_number(context)
+            .unwrap() as _
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        _init: Value,
+    ) -> Result<u32, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        let func = self
+            .handle
+            .table
+            .get_property(context, "grow".to_string())
+            .to_object(context)
+            .unwrap();
+        match func.call(
+            context,
+            Some(&self.handle.table),
+            &[JSValue::number(context, delta as _)],
+        ) {
+            Ok(val) => Ok(val.to_number(context).unwrap() as _),
+            Err(e) => Err(<JSValue as Into<RuntimeError>>::into(e)),
+        }
+    }
+
+    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: 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(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(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..55def4d396
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/tag.rs
@@ -0,0 +1,42 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef,
+    jsc::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+};
+
+#[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 69%
rename from lib/api/src/jsc/trap.rs
rename to lib/api/src/backend/jsc/error.rs
index fa606fc137..02feb2cf89 100644
--- a/lib/api/src/jsc/trap.rs
+++ b/lib/api/src/backend/jsc/error.rs
@@ -1,13 +1,13 @@
 use rusty_jsc::{JSContext, JSObject, JSValue};
 
-use crate::RuntimeError;
+use crate::{RuntimeError, jsc::vm::VMExceptionRef};
 use std::error::Error;
 use std::fmt;
 
 #[derive(Debug)]
 enum InnerTrap {
     User(Box<dyn Error + Send + Sync>),
-    JSC(JSValue),
+    Jsc(JSValue),
 }
 
 /// A struct representing a Trap
@@ -52,23 +52,33 @@ impl Trap {
         }
     }
 
-    pub(crate) fn into_jsvalue(self, ctx: &JSContext) -> JSValue {
+    /// Returns true if the `Trap` is an exception
+    pub fn is_exception(&self) -> bool {
+        false
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        None
+    }
+
+    pub(crate) fn into_jsc_value(self, ctx: &JSContext) -> JSValue {
         match self.inner {
             InnerTrap::User(err) => {
                 let obj = JSObject::new(ctx);
                 let err_ptr = Box::leak(Box::new(err));
-                let wasmer_error_ptr = JSValue::number(&ctx, err_ptr as *mut _ as usize as _);
-                obj.set_property(&ctx, "wasmer_error_ptr".to_string(), wasmer_error_ptr)
+                let wasmer_error_ptr = JSValue::number(ctx, err_ptr as *mut _ as usize as _);
+                obj.set_property(ctx, "wasmer_error_ptr".to_string(), wasmer_error_ptr)
                     .unwrap();
                 obj.to_jsvalue()
             }
-            InnerTrap::JSC(value) => value,
+            InnerTrap::Jsc(value) => value,
         }
     }
 
-    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());
+        let wasmer_error_ptr = obj_val.get_property(ctx, "wasmer_error_ptr".to_string());
         if wasmer_error_ptr.is_number(ctx) {
             let err_ptr = wasmer_error_ptr.to_number(ctx).unwrap() as usize
                 as *mut Box<dyn Error + Send + Sync>;
@@ -76,7 +86,7 @@ impl Trap {
             return Self::user(*err);
         }
         Self {
-            inner: InnerTrap::JSC(val),
+            inner: InnerTrap::Jsc(val),
         }
     }
 }
@@ -93,8 +103,8 @@ impl std::error::Error for Trap {
 impl fmt::Display for Trap {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.inner {
-            InnerTrap::User(e) => write!(f, "user: {}", e),
-            InnerTrap::JSC(value) => write!(f, "jsc: obscure"),
+            InnerTrap::User(e) => write!(f, "user: {e}"),
+            InnerTrap::Jsc(_value) => write!(f, "jsc: obscure"),
         }
     }
 }
@@ -102,7 +112,7 @@ impl fmt::Display for Trap {
 impl From<JSValue> for RuntimeError {
     fn from(original: JSValue) -> Self {
         let trap = Trap {
-            inner: InnerTrap::JSC(original),
+            inner: InnerTrap::Jsc(original),
         };
         trap.into()
         // unimplemented!("TODO: implement Trap::from(JSValue) for RuntimeError");
@@ -115,3 +125,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();
+        }
+
+        Self::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/backend/jsc/utils/convert.rs b/lib/api/src/backend/jsc/utils/convert.rs
new file mode 100644
index 0000000000..1b545b2f04
--- /dev/null
+++ b/lib/api/src/backend/jsc/utils/convert.rs
@@ -0,0 +1,168 @@
+use rusty_jsc::{JSContext, JSValue};
+use wasmer_types::{ExternType, Type};
+
+use crate::{AsStoreMut, AsStoreRef, Extern, Function, Value, jsc::engine::IntoJSC};
+
+/// Convert the given type to a [`JsValue`].
+pub trait AsJsc: Sized {
+    /// The inner definition type from this Javascript object
+    type DefinitionType;
+    /// Convert the given type to a [`JsValue`].
+    fn as_jsc_value(&self, store: &impl AsStoreRef) -> JSValue;
+    /// Convert the given type to a [`JsValue`].
+    fn from_jsc_value(
+        store: &mut impl AsStoreMut,
+        type_: &Self::DefinitionType,
+        value: &JSValue,
+    ) -> Result<Self, JSValue>;
+}
+
+#[inline]
+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 => {
+            let number = if js_val.is_number(context) {
+                js_val.to_number(context).unwrap() as _
+            } else {
+                js_val
+                    .to_string(context)
+                    .unwrap()
+                    .to_string()
+                    .parse()
+                    .unwrap()
+            };
+            Value::I64(number)
+        }
+        Type::F32 => Value::F32(js_val.to_number(context).unwrap() as _),
+        Type::F64 => Value::F64(js_val.to_number(context).unwrap()),
+        Type::V128 => {
+            let number = if js_val.is_number(context) {
+                js_val.to_number(context).unwrap() as _
+            } else {
+                js_val
+                    .to_string(context)
+                    .unwrap()
+                    .to_string()
+                    .parse()
+                    .unwrap()
+            };
+            Value::V128(number)
+        }
+        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => unimplemented!(
+            "The type `{:?}` is not yet supported in the JSC Function API",
+            ty
+        ),
+    }
+}
+
+impl AsJsc for Value {
+    type DefinitionType = Type;
+
+    fn as_jsc_value(&self, store: &impl AsStoreRef) -> JSValue {
+        let engine = store.as_store_ref();
+        let context = engine.jsc().context();
+        match self {
+            Self::I32(i) => JSValue::number(context, *i as _),
+            // JavascriptCore will fail with:
+            // new WebAssembly.Global({value: "i64", mutable: false}, 3);
+            // But will succeed with
+            // new WebAssembly.Global({value: "i64", mutable: false}, "3");
+            Self::I64(i) => JSValue::string(context, (*i).to_string()),
+            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.as_jsc().handle.function.clone().to_jsvalue(),
+            Self::FuncRef(None) => JSValue::null(context),
+            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_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(jsc_value_to_wasmer(context, type_, value))
+    }
+}
+
+impl AsJsc for Extern {
+    type DefinitionType = ExternType;
+
+    fn as_jsc_value(&self, _store: &impl AsStoreRef) -> JSValue {
+        match self {
+            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_jsc_value(
+        store: &mut impl AsStoreMut,
+        extern_type: &Self::DefinitionType,
+        val: &JSValue,
+    ) -> Result<Self, JSValue> {
+        // Note: this function do a soft check over the type
+        // We only check the "kind" of Extern, but nothing else
+        // unimplemented!();
+        let engine = store.as_store_mut();
+        let context = engine.jsc().context();
+        match extern_type {
+            ExternType::Function(function_type) => {
+                let obj_val = val.to_object(context).unwrap();
+                Ok(Self::Function(Function::from_vm_extern(
+                    store,
+                    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(crate::Global::from_vm_extern(
+                    store,
+                    crate::vm::VMExternGlobal::Jsc(crate::backend::jsc::vm::VMExternGlobal::new(
+                        obj_val,
+                        *global_type,
+                    )),
+                )))
+            }
+            ExternType::Memory(memory_type) => {
+                let obj_val = val.to_object(context).unwrap();
+                Ok(Self::Memory(crate::Memory::from_vm_extern(
+                    store,
+                    crate::vm::VMExternMemory::Jsc(crate::backend::jsc::vm::VMExternMemory::new(
+                        obj_val,
+                        *memory_type,
+                    )),
+                )))
+            }
+            ExternType::Table(table_type) => {
+                let obj_val = val.to_object(context).unwrap();
+                Ok(Self::Table(crate::Table::from_vm_extern(
+                    store,
+                    crate::vm::VMExternTable::Jsc(crate::backend::jsc::vm::VMExternTable::new(
+                        obj_val,
+                        *table_type,
+                    )),
+                )))
+            }
+            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..60460a568a
--- /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<Self, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&self, store: &impl AsStoreRef) -> Result<Self, 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,
+        })
+    }
+}
+
+/// 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/async_runtime.rs b/lib/api/src/backend/sys/async_runtime.rs
new file mode 100644
index 0000000000..0ebaf40684
--- /dev/null
+++ b/lib/api/src/backend/sys/async_runtime.rs
@@ -0,0 +1,326 @@
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    ptr,
+    rc::Rc,
+    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+};
+
+use corosensei::{Coroutine, CoroutineResult, Yielder};
+
+use super::entities::function::Function as SysFunction;
+use crate::{
+    AsStoreMut, AsStoreRef, ForcedStoreInstallGuard, LocalRwLockWriteGuard, RuntimeError, Store,
+    StoreAsync, StoreContext, StoreInner, StoreMut, StoreRef, Value,
+};
+use wasmer_types::StoreId;
+
+type HostFuture = Pin<Box<dyn Future<Output = Result<Vec<Value>, RuntimeError>> + 'static>>;
+
+pub(crate) fn call_function_async(
+    function: SysFunction,
+    store: StoreAsync,
+    params: Vec<Value>,
+) -> AsyncCallFuture {
+    AsyncCallFuture::new(function, store, params)
+}
+
+struct AsyncYield(HostFuture);
+
+enum AsyncResume {
+    Start,
+    HostFutureReady(Result<Vec<Value>, RuntimeError>),
+}
+
+#[allow(clippy::type_complexity)]
+pub(crate) struct AsyncCallFuture {
+    coroutine: Option<Coroutine<AsyncResume, AsyncYield, Result<Box<[Value]>, RuntimeError>>>,
+    pending_store_install: Option<Pin<Box<dyn Future<Output = ForcedStoreInstallGuard>>>>,
+    pending_future: Option<HostFuture>,
+    next_resume: Option<AsyncResume>,
+    result: Option<Result<Box<[Value]>, RuntimeError>>,
+
+    // Store handle we can use to lock the store down
+    store: StoreAsync,
+}
+
+// We can't use any of the existing AsStoreMut types here, since we keep
+// changing the store context underneath us while the coroutine yields.
+// To work around it, we use this dummy struct, which just grabs the store
+// from the store context. Since we always have a store context installed
+// when resuming the coroutine, this is safe in that it can access the store
+// through the store context. HOWEVER, references returned from this struct
+// CAN NOT BE HELD ACROSS A YIELD POINT. We don't do this anywhere in the
+// `Function::call code.
+struct AsyncCallStoreMut {
+    store_id: StoreId,
+}
+
+impl AsStoreRef for AsyncCallStoreMut {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        // Safety: This is only used with Function::call, which doesn't store
+        // the returned reference anywhere, including when calling into WASM
+        // code.
+        unsafe {
+            StoreRef {
+                inner: StoreContext::get_current_transient(self.store_id)
+                    .as_ref()
+                    .unwrap(),
+            }
+        }
+    }
+}
+
+impl AsStoreMut for AsyncCallStoreMut {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        // Safety: This is only used with Function::call, which doesn't store
+        // the returned reference anywhere, including when calling into WASM
+        // code.
+        unsafe {
+            StoreMut {
+                inner: StoreContext::get_current_transient(self.store_id)
+                    .as_mut()
+                    .unwrap(),
+            }
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        // Safety: This is only used with Function::call, which doesn't store
+        // the returned reference anywhere, including when calling into WASM
+        // code.
+        unsafe {
+            &mut StoreContext::get_current_transient(self.store_id)
+                .as_mut()
+                .unwrap()
+                .objects
+        }
+    }
+}
+
+impl AsyncCallFuture {
+    pub(crate) fn new(function: SysFunction, store: StoreAsync, params: Vec<Value>) -> Self {
+        let store_id = store.id;
+        let coroutine =
+            Coroutine::new(move |yielder: &Yielder<AsyncResume, AsyncYield>, resume| {
+                assert!(matches!(resume, AsyncResume::Start));
+
+                let ctx_state = CoroutineContext::new(yielder);
+                ctx_state.enter();
+                let result = {
+                    let mut store_mut = AsyncCallStoreMut { store_id };
+                    function.call(&mut store_mut, &params)
+                };
+                ctx_state.leave();
+                result
+            });
+
+        Self {
+            coroutine: Some(coroutine),
+            pending_store_install: None,
+            pending_future: None,
+            next_resume: Some(AsyncResume::Start),
+            result: None,
+            store,
+        }
+    }
+}
+
+impl Future for AsyncCallFuture {
+    type Output = Result<Box<[Value]>, RuntimeError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            if let Some(future) = self.pending_future.as_mut() {
+                match future.as_mut().poll(cx) {
+                    Poll::Ready(result) => {
+                        self.pending_future = None;
+                        self.next_resume = Some(AsyncResume::HostFutureReady(result));
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+            }
+
+            // If we're ready, return early
+            if self.coroutine.is_none() {
+                return Poll::Ready(self.result.take().expect("polled after completion"));
+            }
+
+            // Start a store installation if not in progress already
+            if self.pending_store_install.is_none() {
+                self.pending_store_install = Some(Box::pin(install_store_context(StoreAsync {
+                    id: self.store.id,
+                    inner: self.store.inner.clone(),
+                })));
+            }
+
+            // Acquiring a store lock should be the last step before resuming
+            // the coroutine, to minimize the time we hold the lock.
+            let store_context_guard = match self
+                .pending_store_install
+                .as_mut()
+                .unwrap()
+                .as_mut()
+                .poll(cx)
+            {
+                Poll::Ready(guard) => {
+                    self.pending_store_install = None;
+                    guard
+                }
+                Poll::Pending => return Poll::Pending,
+            };
+
+            let resume_arg = self.next_resume.take().expect("no resume arg available");
+            let coroutine = self.coroutine.as_mut().unwrap();
+            match coroutine.resume(resume_arg) {
+                CoroutineResult::Yield(AsyncYield(fut)) => {
+                    self.pending_future = Some(fut);
+                }
+                CoroutineResult::Return(result) => {
+                    self.coroutine = None;
+                    self.result = Some(result);
+                }
+            }
+
+            // Uninstall the store context to unlock the store after the coroutine
+            // yields or returns.
+            drop(store_context_guard);
+        }
+    }
+}
+
+async fn install_store_context(store: StoreAsync) -> ForcedStoreInstallGuard {
+    match unsafe { crate::StoreContext::try_get_current_async(store.id) } {
+        crate::GetStoreAsyncGuardResult::NotInstalled => {
+            // We always need to acquire a new write lock on the store.
+            let store_guard = store.inner.write().await;
+            unsafe { crate::StoreContext::install_async(store_guard) }
+        }
+        _ => {
+            // If we're already in a store context, it is unsafe to reuse
+            // the existing store ref since it'll also be accessible from
+            // the imported function that tried to poll us, which is a
+            // double mutable borrow.
+            // Note to people who discover this code: this *would* be safe
+            // if we had a separate variation of call_async that just
+            // used the existing coroutine context instead of spawning a
+            // new coroutine. However, the current call_async always spawns
+            // a new coroutine, so we can't allow this; every coroutine
+            // needs to own its write lock on the store to make sure there
+            // are no overlapping mutable borrows. If this is something
+            // you're interested in, feel free to open a GitHub issue outlining
+            // your use-case.
+            panic!(
+                "Function::call_async futures cannot be polled recursively \
+                    from within another imported function. If you need to await \
+                    a recursive call_async, consider spawning the future into \
+                    your async runtime and awaiting the resulting task; \
+                    e.g. tokio::task::spawn(func.call_async(...)).await"
+            );
+        }
+    }
+}
+
+pub enum AsyncRuntimeError {
+    YieldOutsideAsyncContext,
+    RuntimeError(RuntimeError),
+}
+
+pub(crate) fn block_on_host_future<Fut>(future: Fut) -> Result<Vec<Value>, AsyncRuntimeError>
+where
+    Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+{
+    CURRENT_CONTEXT.with(|cell| {
+        match CoroutineContext::get_current() {
+            None => {
+                // If there is no async context or we haven't entered it,
+                // we can still directly run a future that doesn't block
+                // inline.
+                run_immediate(future)
+            }
+            Some(context) => unsafe { context.as_ref().expect("valid context pointer") }
+                .block_on_future(Box::pin(future))
+                .map_err(AsyncRuntimeError::RuntimeError),
+        }
+    })
+}
+
+thread_local! {
+    static CURRENT_CONTEXT: RefCell<Vec<*const CoroutineContext>> = const { RefCell::new(Vec::new()) };
+}
+
+struct CoroutineContext {
+    yielder: *const Yielder<AsyncResume, AsyncYield>,
+}
+
+impl CoroutineContext {
+    fn new(yielder: &Yielder<AsyncResume, AsyncYield>) -> Self {
+        Self {
+            yielder: yielder as *const _,
+        }
+    }
+
+    fn enter(&self) {
+        CURRENT_CONTEXT.with(|cell| {
+            let mut borrow = cell.borrow_mut();
+
+            // Push this coroutine on top of the active stack.
+            borrow.push(self as *const _);
+        })
+    }
+
+    // Note: we don't use a drop-style guard here on purpose; if a panic
+    // happens while a coroutine is running, CURRENT_CONTEXT will be in
+    // an inconsistent state. corosensei will unwind all coroutine stacks
+    // anyway, and if we had a guard that would get dropped and try to
+    // leave its context, it'd panic again at the assert_eq! below.
+    fn leave(&self) {
+        CURRENT_CONTEXT.with(|cell| {
+            let mut borrow = cell.borrow_mut();
+
+            // Pop this coroutine from the active stack.
+            assert_eq!(
+                borrow.pop(),
+                Some(self as *const _),
+                "Active coroutine stack corrupted"
+            );
+        });
+    }
+
+    fn get_current() -> Option<*const Self> {
+        CURRENT_CONTEXT.with(|cell| cell.borrow().last().copied())
+    }
+
+    fn block_on_future(&self, future: HostFuture) -> Result<Vec<Value>, RuntimeError> {
+        // Leave the coroutine context since we're yielding back to the
+        // parent stack, and will be inactive until the future is ready.
+        self.leave();
+
+        let yielder = unsafe { self.yielder.as_ref().expect("yielder pointer valid") };
+        let result = match yielder.suspend(AsyncYield(future)) {
+            AsyncResume::HostFutureReady(result) => result,
+            AsyncResume::Start => unreachable!("coroutine resumed without start"),
+        };
+
+        // Once the future is ready, we restore the current coroutine
+        // context.
+        self.enter();
+
+        result
+    }
+}
+
+fn run_immediate(
+    future: impl Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+) -> Result<Vec<Value>, AsyncRuntimeError> {
+    let waker = futures::task::noop_waker();
+    let mut cx = Context::from_waker(&waker);
+    let mut future = Box::pin(future);
+    match future.as_mut().poll(&mut cx) {
+        Poll::Ready(result) => result.map_err(AsyncRuntimeError::RuntimeError),
+        Poll::Pending => Err(AsyncRuntimeError::YieldOutsideAsyncContext),
+    }
+}
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..40696a9f26
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/engine.rs
@@ -0,0 +1,287 @@
+//! 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::{CompilationProgressCallback, DeserializeError, Features, target::Target};
+
+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;
+
+    /// 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;
+
+    /// Compile a module from bytes with a progress callback.
+    ///
+    /// The callback is invoked with progress updates during the compilation process.
+    /// The callback also may return an error to abort the compilation.
+    ///
+    /// Signature of the callback function: `Fn(CompilationProgress) -> Result<(), UserAbort> + Send + Sync + 'static`
+    ///
+    /// # Aborting compilation
+    ///
+    /// The callback has to return a `Result<(), UserAbort>`.
+    ///
+    /// If the callback returns an error, the compilation will fail with a `CompileError::Aborted`.
+    fn new_module_with_progress(
+        &self,
+        bytes: &[u8],
+        on_progress: CompilationProgressCallback,
+    ) -> Result<crate::Module, wasmer_types::CompileError>;
+
+    /// 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!"),
+        }
+    }
+
+    fn new_module_with_progress(
+        &self,
+        bytes: &[u8],
+        on_progress: CompilationProgressCallback,
+    ) -> Result<crate::Module, wasmer_types::CompileError> {
+        crate::BackendModule::new_with_progress(self, bytes, on_progress).map(crate::Module)
+    }
+
+    unsafe fn deserialize_from_mmapped_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        let buffer = OwnedBuffer::from_file(&file)
+            .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?;
+        let artifact = unsafe { Arc::new(Artifact::deserialize_unchecked(self.as_sys(), buffer)?) };
+        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 buffer = OwnedBuffer::from_file(&file)
+            .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?;
+        let artifact = unsafe { Arc::new(Artifact::deserialize(self.as_sys(), buffer)?) };
+        Ok(crate::Module(BackendModule::Sys(
+            super::module::Module::from_artifact(artifact),
+        )))
+    }
+}
+
+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..32c3d2e2c4
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/exception.rs
@@ -0,0 +1,104 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+use wasmer_vm::{StoreHandle, StoreId};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTag, Tag, Value,
+    sys::vm::{VMExceptionObj, VMExceptionRef},
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `exnref` in the `sys` runtime.
+pub(crate) struct Exception {
+    exnref: wasmer_vm::VMExceptionRef,
+}
+
+impl Exception {
+    /// Creates a new exception with the given tag and payload, and also creates
+    /// a reference to it, returning the reference.
+    #[allow(irrefutable_let_patterns)]
+    pub fn new(store: &mut impl AsStoreMut, tag: &crate::sys::tag::Tag, payload: &[Value]) -> Self {
+        if !tag.is_from_store(store) {
+            panic!("cannot create Exception with Tag from another Store");
+        }
+
+        let store_objects = store.as_store_ref().objects().as_sys();
+        let store_id = store_objects.id();
+
+        let tag_ty = tag.handle.get(store_objects).signature.params();
+
+        if tag_ty.len() != payload.len() {
+            panic!("payload length mismatch");
+        }
+
+        let values = payload
+            .iter()
+            .enumerate()
+            .map(|(i, v)| {
+                if v.ty() != tag_ty[i] {
+                    panic!("payload type mismatch");
+                }
+                v.as_raw(store)
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        let ctx = store.objects_mut().as_sys_mut();
+        let exception = wasmer_vm::VMExceptionObj::new(tag.handle.internal_handle(), values);
+        let exn_handle = wasmer_vm::StoreHandle::new(ctx, exception);
+        let exnref = wasmer_vm::VMExceptionRef(exn_handle);
+
+        Self { exnref }
+    }
+
+    pub fn exnref(&self) -> wasmer_vm::VMExceptionRef {
+        self.exnref.clone()
+    }
+
+    pub fn from_exnref(exnref: wasmer_vm::VMExceptionRef) -> Self {
+        Self { exnref }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.exnref.0.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub fn tag(&self, store: &impl AsStoreRef) -> crate::sys::tag::Tag {
+        if !self.is_from_store(store) {
+            panic!("Exception is from another Store");
+        }
+        let ctx = store.as_store_ref().objects().as_sys();
+        let exception = self.exnref.0.get(ctx);
+        let tag_handle = exception.tag();
+        crate::sys::tag::Tag {
+            handle: unsafe { StoreHandle::from_internal(ctx.id(), tag_handle) },
+        }
+    }
+
+    pub fn payload(&self, store: &mut impl AsStoreMut) -> Vec<Value> {
+        if !self.is_from_store(store) {
+            panic!("Exception is from another Store");
+        }
+        let ctx = store.as_store_ref().objects().as_sys();
+        let exception = self.exnref.0.get(ctx);
+        let params_ty = exception.tag().get(ctx).signature.params().to_vec();
+        let payload_ptr = exception.payload();
+
+        assert_eq!(params_ty.len(), payload_ptr.len());
+
+        params_ty
+            .iter()
+            .zip(unsafe { payload_ptr.as_ref().iter() })
+            .map(|(ty, raw)| unsafe { Value::from_raw(store, *ty, *raw) })
+            .collect()
+    }
+}
+
+#[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..ac1cc3ad1a
--- /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: unsafe { 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..db823169b8
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/function/env.rs
@@ -0,0 +1,413 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+#[cfg(feature = "experimental-async")]
+use crate::{AsStoreAsync, StoreAsync, StoreAsyncReadLock, StoreAsyncWriteLock};
+use crate::{
+    Store, StoreContext, StoreInner, StoreMut, StorePtrWrapper,
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+};
+
+use wasmer_vm::{StoreHandle, StoreId, 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: Any + Send + 'static + Sized> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_sys_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    #[allow(dead_code)] // This function is only used in js
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T: Any + 'static + Sized> FunctionEnv<T> {
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T {
+        self.handle
+            .get_mut(store.objects_mut().as_sys_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+}
+
+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())
+    }
+
+    /// Returns a [`StoreAsync`] if the current
+    /// context is asynchronous. The store will be locked since
+    /// it's already active in the current context, but can be used
+    /// to spawn new coroutines via
+    /// [`Function::call_async`](crate::Function::call_async).
+    #[cfg(feature = "experimental-async")]
+    pub fn as_store_async(&self) -> Option<impl AsStoreAsync + 'static> {
+        self.store_mut.as_store_async()
+    }
+}
+
+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))
+    }
+}
+
+/// A shared handle to a [`FunctionEnv`], suitable for use
+/// in async imports.
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvMut<T> {
+    pub(crate) store: AsyncFunctionEnvMutStore,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+// We need to let async functions that *don't suspend* run
+// in a sync context. To that end, `AsyncFunctionEnvMut`
+// must be able to be constructed without an actual
+// StoreAsync instance, hence this enum.
+#[cfg(feature = "experimental-async")]
+pub(crate) enum AsyncFunctionEnvMutStore {
+    Async(StoreAsync),
+    Sync(StorePtrWrapper),
+}
+
+/// A read-only handle to the [`FunctionEnv`] in an [`AsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvHandle<T> {
+    read_lock: StoreAsyncReadLock,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+/// A mutable handle to the [`FunctionEnv`] in an [`AsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvHandleMut<T> {
+    write_lock: StoreAsyncWriteLock,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T> Debug for AsyncFunctionEnvMut<T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.store {
+            AsyncFunctionEnvMutStore::Sync(ptr) => self.func_env.as_ref(&ptr.as_ref()).fmt(f),
+            AsyncFunctionEnvMutStore::Async(store) => match store.inner.try_read() {
+                Some(read_lock) => self.func_env.as_ref(&read_lock).fmt(f),
+                None => write!(f, "AsyncFunctionEnvMut {{ <STORE LOCKED> }}"),
+            },
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvMut<T> {
+    pub(crate) fn store_id(&self) -> StoreId {
+        match &self.store {
+            AsyncFunctionEnvMutStore::Sync(ptr) => ptr.as_ref().objects().id(),
+            AsyncFunctionEnvMutStore::Async(store) => store.id,
+        }
+    }
+
+    /// Waits for a store lock and returns a read-only handle to the
+    /// function environment.
+    pub async fn read(&self) -> AsyncFunctionEnvHandle<T> {
+        let read_lock = match &self.store {
+            AsyncFunctionEnvMutStore::Async(store) => store.read_lock().await,
+
+            // We can never acquire a store lock in a sync context
+            AsyncFunctionEnvMutStore::Sync(_) => futures::future::pending().await,
+        };
+
+        AsyncFunctionEnvHandle {
+            read_lock,
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Waits for a store lock and returns a mutable handle to the
+    /// function environment.
+    pub async fn write(&self) -> AsyncFunctionEnvHandleMut<T> {
+        let write_lock = match &self.store {
+            AsyncFunctionEnvMutStore::Async(store) => store.write_lock().await,
+
+            // We can never acquire a store lock in a sync context
+            AsyncFunctionEnvMutStore::Sync(_) => futures::future::pending().await,
+        };
+
+        AsyncFunctionEnvHandleMut {
+            write_lock,
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// 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) -> Self {
+        self.clone()
+    }
+
+    /// Creates an [`AsStoreAsync`] from this [`AsyncFunctionEnvMut`].
+    pub fn as_store_async(&self) -> impl AsStoreAsync + 'static {
+        match &self.store {
+            AsyncFunctionEnvMutStore::Sync(_) => {
+                panic!("Cannot build a StoreAsync within a sync context")
+            }
+            AsyncFunctionEnvMutStore::Async(store) => StoreAsync {
+                id: store.id,
+                inner: store.inner.clone(),
+            },
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T> Clone for AsyncFunctionEnvMut<T> {
+    fn clone(&self) -> Self {
+        Self {
+            store: self.store.clone(),
+            func_env: self.func_env.clone(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl Clone for AsyncFunctionEnvMutStore {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Async(store) => Self::Async(StoreAsync {
+                id: store.id,
+                inner: store.inner.clone(),
+            }),
+            Self::Sync(ptr) => Self::Sync(ptr.clone()),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvHandle<T> {
+    /// Returns a reference to the host state in this function environment.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.read_lock)
+    }
+
+    /// Returns both the host state and the attached StoreRef
+    pub fn data_and_store(&self) -> (&T, &impl AsStoreRef) {
+        (self.data(), &self.read_lock)
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for AsyncFunctionEnvHandle<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        AsStoreRef::as_store_ref(&self.read_lock)
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvHandleMut<T> {
+    /// Returns a mutable reference to the host state in this function environment.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.write_lock)
+    }
+
+    /// Returns both the host state and the attached StoreMut
+    pub fn data_and_store_mut(&mut self) -> (&mut T, &mut impl AsStoreMut) {
+        let data = self.data_mut() as *mut T;
+        // Wisdom of the ancients:
+        // 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, &mut self.write_lock)
+    }
+
+    /// Borrows a new [`FunctionEnvMut`] from this [`AsyncFunctionEnvHandleMut`].
+    pub fn as_function_env_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.write_lock.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for AsyncFunctionEnvHandleMut<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        AsStoreRef::as_store_ref(&self.write_lock)
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreMut for AsyncFunctionEnvHandleMut<T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        AsStoreMut::as_store_mut(&mut self.write_lock)
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        AsStoreMut::objects_mut(&mut self.write_lock)
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/function/mod.rs b/lib/api/src/backend/sys/entities/function/mod.rs
new file mode 100644
index 0000000000..04a364f9bf
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/function/mod.rs
@@ -0,0 +1,1144 @@
+//! Data types, functions and traits for `sys` runtime's `Function` implementation.
+
+pub(crate) mod env;
+pub(crate) mod typed;
+
+#[cfg(feature = "experimental-async")]
+use crate::{
+    AsStoreAsync, AsyncFunctionEnvMut, BackendAsyncFunctionEnvMut, StoreAsync,
+    entities::function::async_host::{AsyncFunctionEnv, AsyncHostFunction},
+    sys::{
+        async_runtime::{AsyncRuntimeError, block_on_host_future, call_function_async},
+        function::env::AsyncFunctionEnvMutStore,
+    },
+};
+use crate::{
+    BackendFunction, FunctionEnv, FunctionEnvMut, FunctionType, HostFunction, RuntimeError,
+    StoreContext, StoreInner, Value, WithEnv, WithoutEnv,
+    backend::sys::{engine::NativeEngineExt, vm::VMFunctionCallback},
+    entities::store::{AsStoreMut, AsStoreRef, StoreMut},
+    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
+    vm::{VMExtern, VMExternFunction},
+};
+use std::panic::{self, AssertUnwindSafe};
+use std::{
+    cell::UnsafeCell, cmp::max, error::Error, ffi::c_void, future::Future, marker::PhantomData,
+    pin::Pin, sync::Arc,
+};
+use wasmer_types::{NativeWasmType, RawValue, StoreId};
+use wasmer_vm::{
+    MaybeInstanceOwned, StoreHandle, Trap, TrapCode, VMCallerCheckedAnyfunc, VMContext,
+    VMDynamicFunctionContext, VMFuncRef, VMFunction, VMFunctionBody, VMFunctionContext,
+    VMFunctionKind, VMTrampoline, on_host_stack, raise_lib_trap, raise_user_trap, resume_panic,
+    wasmer_call_trampoline,
+};
+
+#[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>,
+}
+
+impl From<StoreHandle<VMFunction>> for Function {
+    fn from(handle: StoreHandle<VMFunction>) -> Self {
+        Self { handle }
+    }
+}
+
+impl Function {
+    pub(crate) 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 function_type = ty.into();
+        let func_ty = function_type.clone();
+        let func_env = env.clone().into_sys();
+        let store_id = store.objects_mut().id();
+        let wrapper = move |values_vec: *mut RawValue| -> HostCallOutcome {
+            unsafe {
+                let mut store_wrapper = unsafe { StoreContext::get_current(store_id) };
+                let mut store_mut = store_wrapper.as_mut();
+                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_mut,
+                        *ty,
+                        values_vec.add(i).read_unaligned(),
+                    ));
+                }
+                let env = env::FunctionEnvMut {
+                    store_mut,
+                    func_env: func_env.clone(),
+                }
+                .into();
+                let sig = func_ty.clone();
+                let result = func(env, &args);
+                HostCallOutcome::Ready {
+                    func_ty: sig,
+                    result,
+                }
+            }
+        };
+        let mut host_data = Box::new(VMDynamicFunctionContext {
+            address: std::ptr::null(),
+            ctx: DynamicFunction {
+                func: wrapper,
+                store_id,
+            },
+        });
+        host_data.address = host_data.ctx.func_body_ptr();
+
+        // We don't yet have the address with the Wasm ABI signature.
+        // The engine linker will replace the address with one pointing to a
+        // generated dynamic trampoline.
+        let func_ptr = std::ptr::null() as VMFunctionCallback;
+        let type_index = store
+            .as_store_ref()
+            .engine()
+            .as_sys()
+            .register_signature(&function_type);
+        let vmctx = VMFunctionContext {
+            host_env: host_data.as_ref() as *const _ as *mut c_void,
+        };
+        let call_trampoline = host_data.ctx.call_trampoline_address();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Dynamic,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
+        }
+    }
+
+    #[cfg(feature = "experimental-async")]
+    pub(crate) fn new_async<FT, F, Fut>(store: &mut impl AsStoreMut, ty: FT, func: F) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(&[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        let env = FunctionEnv::new(store, ());
+        let wrapped = move |_env: AsyncFunctionEnvMut<()>, values: &[Value]| func(values);
+        Self::new_with_env_async(store, &env, ty, wrapped)
+    }
+
+    #[cfg(feature = "experimental-async")]
+    pub(crate) fn new_with_env_async<FT, F, Fut, T: 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(AsyncFunctionEnvMut<T>, &[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        let function_type = ty.into();
+        let func_ty = function_type.clone();
+        let func_env = env.clone().into_sys();
+        let store_id = store.objects_mut().id();
+        let wrapper = move |values_vec: *mut RawValue| -> HostCallOutcome {
+            unsafe {
+                let mut context = StoreContext::try_get_current_async(store_id);
+                let mut store_mut = match &mut context {
+                    crate::GetStoreAsyncGuardResult::Ok(wrapper) => StoreMut {
+                        inner: wrapper.guard.as_mut().unwrap(),
+                    },
+                    crate::GetStoreAsyncGuardResult::NotAsync(ptr) => ptr.as_mut(),
+                    crate::GetStoreAsyncGuardResult::NotInstalled => {
+                        panic!("No store context installed on this thread")
+                    }
+                };
+                let id = store_mut.as_store_ref().objects().id();
+                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_mut,
+                        *ty,
+                        values_vec.add(i).read_unaligned(),
+                    ));
+                }
+                let store_async = match context {
+                    crate::GetStoreAsyncGuardResult::Ok(wrapper) => {
+                        AsyncFunctionEnvMutStore::Async(StoreAsync {
+                            id,
+                            inner: crate::LocalRwLockWriteGuard::lock_handle(
+                                wrapper.guard.as_mut().unwrap(),
+                            ),
+                        })
+                    }
+                    crate::GetStoreAsyncGuardResult::NotAsync(ptr) => {
+                        AsyncFunctionEnvMutStore::Sync(ptr)
+                    }
+                    crate::GetStoreAsyncGuardResult::NotInstalled => unreachable!(),
+                };
+                let env = crate::AsyncFunctionEnvMut(crate::BackendAsyncFunctionEnvMut::Sys(
+                    env::AsyncFunctionEnvMut {
+                        store: store_async,
+                        func_env: func_env.clone(),
+                    },
+                ));
+                let sig = func_ty.clone();
+                let future = func(env, &args);
+                HostCallOutcome::Future {
+                    func_ty: sig,
+                    future: Box::pin(future),
+                }
+            }
+        };
+        let mut host_data = Box::new(VMDynamicFunctionContext {
+            address: std::ptr::null(),
+            ctx: DynamicFunction {
+                func: wrapper,
+                store_id,
+            },
+        });
+        host_data.address = host_data.ctx.func_body_ptr();
+
+        let func_ptr = std::ptr::null() as VMFunctionCallback;
+        let type_index = store
+            .as_store_ref()
+            .engine()
+            .as_sys()
+            .register_signature(&function_type);
+        let vmctx = VMFunctionContext {
+            host_env: host_data.as_ref() as *const _ as *mut c_void,
+        };
+        let call_trampoline = host_data.ctx.call_trampoline_address();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Dynamic,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    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_sys().into_sys();
+        let host_data = Box::new(StaticFunction {
+            store_id: store.objects_mut().id(),
+            env,
+            func,
+        });
+        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+
+        let type_index = store
+            .as_store_ref()
+            .engine()
+            .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().into_sys();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Static,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
+        }
+    }
+
+    #[cfg(feature = "experimental-async")]
+    pub(crate) fn new_typed_async<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        Args: WasmTypeList + 'static,
+        Rets: WasmTypeList + 'static,
+        F: AsyncHostFunction<(), Args, Rets, WithoutEnv> + 'static,
+    {
+        let env = FunctionEnv::new(store, ());
+        let signature = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+        let args_sig = Arc::new(signature.clone());
+        let results_sig = Arc::new(signature.clone());
+        let func = Arc::new(func);
+        Self::new_with_env_async(
+            store,
+            &env,
+            signature,
+            move |mut env_mut,
+                  values|
+                  -> Pin<Box<dyn Future<Output = Result<Vec<Value>, RuntimeError>>>> {
+                let sys_env = match env_mut.0 {
+                    BackendAsyncFunctionEnvMut::Sys(ref mut sys_env) => sys_env,
+                    _ => panic!("Not a sys backend"),
+                };
+                let mut store_mut_wrapper =
+                    unsafe { StoreContext::get_current(sys_env.store_id()) };
+                let mut store_mut = store_mut_wrapper.as_mut();
+                let args_sig = args_sig.clone();
+                let results_sig = results_sig.clone();
+                let func = func.clone();
+                let args =
+                    match typed_args_from_values::<Args>(&mut store_mut, args_sig.as_ref(), values)
+                    {
+                        Ok(args) => args,
+                        Err(err) => return Box::pin(async { Err(err) }),
+                    };
+                drop(store_mut_wrapper);
+                let future = func.as_ref().call_async(AsyncFunctionEnv::new(), args);
+                Box::pin(async move {
+                    let typed_result = future.await?;
+                    let mut store_mut = env_mut.write().await;
+                    typed_results_to_values::<Rets>(
+                        &mut store_mut.as_store_mut(),
+                        results_sig.as_ref(),
+                        typed_result,
+                    )
+                })
+            },
+        )
+    }
+
+    #[cfg(feature = "experimental-async")]
+    pub(crate) fn new_typed_with_env_async<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        T: 'static,
+        F: AsyncHostFunction<T, Args, Rets, WithEnv> + 'static,
+        Args: WasmTypeList + 'static,
+        Rets: WasmTypeList + 'static,
+    {
+        let signature = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+        let args_sig = Arc::new(signature.clone());
+        let results_sig = Arc::new(signature.clone());
+        let func = Arc::new(func);
+        Self::new_with_env_async(
+            store,
+            env,
+            signature,
+            move |mut env_mut,
+                  values|
+                  -> Pin<Box<dyn Future<Output = Result<Vec<Value>, RuntimeError>>>> {
+                let sys_env = match env_mut.0 {
+                    BackendAsyncFunctionEnvMut::Sys(ref mut sys_env) => sys_env,
+                    _ => panic!("Not a sys backend"),
+                };
+                let mut store_mut_wrapper =
+                    unsafe { StoreContext::get_current(sys_env.store_id()) };
+                let mut store_mut = store_mut_wrapper.as_mut();
+                let args_sig = args_sig.clone();
+                let results_sig = results_sig.clone();
+                let func = func.clone();
+                let args =
+                    match typed_args_from_values::<Args>(&mut store_mut, args_sig.as_ref(), values)
+                    {
+                        Ok(args) => args,
+                        Err(err) => return Box::pin(async { Err(err) }),
+                    };
+                drop(store_mut_wrapper);
+                let env_mut_clone = env_mut.as_mut();
+                let future = func
+                    .as_ref()
+                    .call_async(AsyncFunctionEnv::with_env(env_mut), args);
+                Box::pin(async move {
+                    let typed_result = future.await?;
+                    let mut store_mut = env_mut_clone.write().await;
+                    typed_results_to_values::<Rets>(
+                        &mut store_mut.as_store_mut(),
+                        results_sig.as_ref(),
+                        typed_result,
+                    )
+                })
+            },
+        )
+    }
+
+    pub(crate) 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,
+    {
+        let func_ptr = func.function_callback_sys().into_sys();
+        let host_data = Box::new(StaticFunction {
+            store_id: store.objects_mut().id(),
+            env: env.as_sys().clone().into(),
+            func,
+        });
+        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+
+        let type_index = store
+            .as_store_ref()
+            .engine()
+            .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().into_sys();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Static,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
+        }
+    }
+
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .signature
+            .clone()
+    }
+
+    fn call_wasm(
+        &self,
+        store: &mut impl AsStoreMut,
+        trampoline: VMTrampoline,
+        params: &[Value],
+        results: &mut [Value],
+    ) -> Result<(), RuntimeError> {
+        let format_types_for_error_message = |items: &[Value]| {
+            items
+                .iter()
+                .map(|param| param.ty().to_string())
+                .collect::<Vec<String>>()
+                .join(", ")
+        };
+        // TODO: Avoid cloning the signature here, it's expensive.
+        let signature = self.ty(store);
+        if signature.params().len() != params.len() {
+            return Err(RuntimeError::new(format!(
+                "Parameters of type [{}] did not match signature {}",
+                format_types_for_error_message(params),
+                &signature
+            )));
+        }
+        if signature.results().len() != results.len() {
+            return Err(RuntimeError::new(format!(
+                "Results of type [{}] did not match signature {}",
+                format_types_for_error_message(results),
+                &signature,
+            )));
+        }
+
+        let mut values_vec = vec![RawValue { i32: 0 }; max(params.len(), results.len())];
+
+        // Store the argument values into `values_vec`.
+        let param_tys = signature.params().iter();
+        for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) {
+            if arg.ty() != *ty {
+                let param_types = format_types_for_error_message(params);
+                return Err(RuntimeError::new(format!(
+                    "Parameters of type [{}] did not match signature {}",
+                    param_types, &signature,
+                )));
+            }
+            if !arg.is_from_store(store) {
+                return Err(RuntimeError::new("cross-`Store` values are not supported"));
+            }
+            *slot = arg.as_raw(store);
+        }
+
+        // Invoke the call
+        self.call_wasm_raw(store, trampoline, values_vec, results)?;
+        Ok(())
+    }
+
+    fn call_wasm_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        trampoline: VMTrampoline,
+        mut params: Vec<RawValue>,
+        results: &mut [Value],
+    ) -> Result<(), RuntimeError> {
+        // Call the trampoline.
+        let result = {
+            let store_id = store.objects_mut().id();
+            // Safety: the store context is uninstalled before we return, and the
+            // store mut is valid for the duration of the call.
+            let store_install_guard =
+                unsafe { StoreContext::ensure_installed(store.as_store_mut().inner as *mut _) };
+
+            let mut r;
+            // 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().as_sys());
+                let config = storeref.engine().tunables().vmconfig();
+                let signal_handler = storeref.signal_handler();
+                r = unsafe {
+                    // Safety: This is the intended use-case for StoreContext::pause, as
+                    // documented in the function's doc comments.
+                    let pause_guard = StoreContext::pause(store_id);
+                    wasmer_call_trampoline(
+                        signal_handler,
+                        config,
+                        vm_function.anyfunc.as_ptr().as_ref().vmctx,
+                        trampoline,
+                        vm_function.anyfunc.as_ptr().as_ref().func_ptr,
+                        params.as_mut_ptr() as *mut u8,
+                    )
+                };
+                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;
+            }
+
+            drop(store_install_guard);
+
+            r
+        };
+
+        if let Err(error) = result {
+            return Err(error.into());
+        }
+
+        // Load the return values out of `values_vec`.
+        let signature = self.ty(store);
+        for (index, &value_type) in signature.results().iter().enumerate() {
+            unsafe {
+                results[index] = Value::from_raw(store, value_type, params[index]);
+            }
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn result_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).results().len()
+    }
+
+    pub(crate) fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let trampoline = unsafe {
+            self.handle
+                .get(store.objects_mut().as_sys())
+                .anyfunc
+                .as_ptr()
+                .as_ref()
+                .call_trampoline
+        };
+        let mut results = vec![Value::null(); self.result_arity(store)];
+        self.call_wasm(store, trampoline, params, &mut results)?;
+        Ok(results.into_boxed_slice())
+    }
+
+    #[cfg(feature = "experimental-async")]
+    #[allow(clippy::type_complexity)]
+    pub(crate) fn call_async(
+        &self,
+        store: &impl AsStoreAsync,
+        params: Vec<Value>,
+    ) -> Pin<Box<dyn Future<Output = Result<Box<[Value]>, RuntimeError>> + 'static>> {
+        let function = self.clone();
+        let store = store.store();
+        Box::pin(call_function_async(function, store, params))
+    }
+
+    #[doc(hidden)]
+    #[allow(missing_docs)]
+    pub(crate) fn call_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let trampoline = unsafe {
+            self.handle
+                .get(store.objects_mut().as_sys())
+                .anyfunc
+                .as_ptr()
+                .as_ref()
+                .call_trampoline
+        };
+        let mut results = vec![Value::null(); self.result_arity(store)];
+        self.call_wasm_raw(store, trampoline, params, &mut results)?;
+        Ok(results.into_boxed_slice())
+    }
+
+    pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
+        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");
+        }
+        VMFuncRef(vm_function.anyfunc.as_ptr())
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
+        let signature = {
+            let anyfunc = unsafe { funcref.0.as_ref() };
+            store
+                .as_store_mut()
+                .engine()
+                .as_sys()
+                .lookup_signature(anyfunc.type_index)
+                .expect("Signature not found in store")
+        };
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Instance(funcref.0),
+            signature,
+            // All functions in tables are already Static (as dynamic functions
+            // are converted to use the trampolines with static signatures).
+            kind: wasmer_vm::VMFunctionKind::Static,
+            host_data: Box::new(()),
+        };
+        Self {
+            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.objects_mut().id(), vm_extern.into_sys())
+            },
+        }
+    }
+
+    /// Checks whether this `Function` can be used with the given store.
+    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::Function(self.handle.internal_handle()))
+    }
+}
+
+// We want to keep as much logic as possible on the host stack,
+// since the WASM stack may be out of memory. In that scenario,
+// throwing exceptions won't work since libunwind requires
+// considerable stack space to do its magic, but everything else
+// should work.
+enum InvocationResult<T, E> {
+    Success(T),
+    Exception(crate::Exception),
+    Trap(Box<E>),
+    YieldOutsideAsyncContext,
+}
+
+fn to_invocation_result<T, E>(result: Result<T, E>) -> InvocationResult<T, E>
+where
+    E: Error + 'static,
+{
+    match result {
+        Ok(value) => InvocationResult::Success(value),
+        Err(trap) => {
+            let dyn_err_ref = &trap as &dyn Error;
+            if let Some(runtime_error) = dyn_err_ref.downcast_ref::<RuntimeError>()
+                && let Some(exception) = runtime_error.to_exception()
+            {
+                return InvocationResult::Exception(exception);
+            }
+            InvocationResult::Trap(Box::new(trap))
+        }
+    }
+}
+
+fn write_dynamic_results(
+    store_id: StoreId,
+    func_ty: &FunctionType,
+    returns: Vec<Value>,
+    values_vec: *mut RawValue,
+) -> Result<(), RuntimeError> {
+    let mut store_wrapper = unsafe { StoreContext::get_current(store_id) };
+    let mut store = store_wrapper.as_mut();
+    let return_types = returns.iter().map(|ret| ret.ty());
+    if return_types.ne(func_ty.results().iter().copied()) {
+        return Err(RuntimeError::new(format!(
+            "Dynamic function returned wrong signature. Expected {:?} but got {:?}",
+            func_ty.results(),
+            returns.iter().map(|ret| ret.ty())
+        )));
+    }
+    for (i, ret) in returns.iter().enumerate() {
+        unsafe {
+            values_vec.add(i).write_unaligned(ret.as_raw(&store));
+        }
+    }
+    Ok(())
+}
+
+fn finalize_dynamic_call(
+    store_id: StoreId,
+    func_ty: FunctionType,
+    values_vec: *mut RawValue,
+    result: Result<Vec<Value>, RuntimeError>,
+) -> Result<(), RuntimeError> {
+    match result {
+        Ok(values) => write_dynamic_results(store_id, &func_ty, values, values_vec),
+        Err(err) => Err(err),
+    }
+}
+
+fn typed_args_from_values<Args>(
+    store: &mut StoreMut,
+    func_ty: &FunctionType,
+    values: &[Value],
+) -> Result<Args, RuntimeError>
+where
+    Args: WasmTypeList,
+{
+    if values.len() != func_ty.params().len() {
+        return Err(RuntimeError::new(
+            "typed host function received wrong number of parameters",
+        ));
+    }
+    let mut raw_array = Args::empty_array();
+    for ((slot, value), expected_ty) in raw_array
+        .as_mut()
+        .iter_mut()
+        .zip(values.iter())
+        .zip(func_ty.params().iter())
+    {
+        debug_assert_eq!(
+            value.ty(),
+            *expected_ty,
+            "wasm should only call host functions with matching signatures"
+        );
+        *slot = value.as_raw(store);
+    }
+    unsafe { Ok(Args::from_array(store, raw_array)) }
+}
+
+fn typed_results_to_values<Rets>(
+    store: &mut StoreMut,
+    func_ty: &FunctionType,
+    rets: Rets,
+) -> Result<Vec<Value>, RuntimeError>
+where
+    Rets: WasmTypeList,
+{
+    let mut raw_array = unsafe { rets.into_array(store) };
+    let mut values = Vec::with_capacity(func_ty.results().len());
+    for (raw, ty) in raw_array.as_mut().iter().zip(func_ty.results().iter()) {
+        unsafe {
+            values.push(Value::from_raw(store, *ty, *raw));
+        }
+    }
+    Ok(values)
+}
+
+pub(crate) enum HostCallOutcome {
+    Ready {
+        func_ty: FunctionType,
+        result: Result<Vec<Value>, RuntimeError>,
+    },
+    #[cfg(feature = "experimental-async")]
+    Future {
+        func_ty: FunctionType,
+        future: Pin<Box<dyn Future<Output = Result<Vec<Value>, RuntimeError>>>>,
+    },
+}
+
+/// Host state for a dynamic function.
+pub(crate) struct DynamicFunction<F> {
+    func: F,
+    store_id: StoreId,
+}
+
+impl<F> DynamicFunction<F>
+where
+    F: Fn(*mut RawValue) -> HostCallOutcome + 'static,
+{
+    // This function wraps our func, to make it compatible with the
+    // reverse trampoline signature
+    unsafe extern "C-unwind" fn func_wrapper(
+        this: &mut VMDynamicFunctionContext<Self>,
+        values_vec: *mut RawValue,
+    ) {
+        let result = on_host_stack(|| {
+            panic::catch_unwind(AssertUnwindSafe(|| match (this.ctx.func)(values_vec) {
+                HostCallOutcome::Ready { func_ty, result } => to_invocation_result(
+                    finalize_dynamic_call(this.ctx.store_id, func_ty, values_vec, result),
+                ),
+                #[cfg(feature = "experimental-async")]
+                HostCallOutcome::Future { func_ty, future } => {
+                    let awaited = block_on_host_future(future);
+                    let result = match awaited {
+                        Ok(value) => Ok(value),
+                        Err(AsyncRuntimeError::RuntimeError(e)) => Err(e),
+                        Err(AsyncRuntimeError::YieldOutsideAsyncContext) => {
+                            return InvocationResult::YieldOutsideAsyncContext;
+                        }
+                    };
+                    to_invocation_result(finalize_dynamic_call(
+                        this.ctx.store_id,
+                        func_ty,
+                        values_vec,
+                        result,
+                    ))
+                }
+            }))
+        });
+
+        // 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(InvocationResult::Success(())) => {}
+            Ok(InvocationResult::Exception(exception)) => unsafe {
+                // Note: can't acquire a proper ref-counted context ref here, since we can switch
+                // away from the WASM stack at any time.
+                // Safety: The pointer is only used for the duration of the call to `throw`.
+                let mut store_wrapper = StoreContext::get_current_transient(this.ctx.store_id);
+                let mut store = store_wrapper.as_mut().unwrap();
+                wasmer_vm::libcalls::throw(
+                    store.objects.as_sys(),
+                    exception.vm_exceptionref().as_sys().to_u32_exnref(),
+                )
+            },
+            Ok(InvocationResult::Trap(trap)) => unsafe { raise_user_trap(trap) },
+            Ok(InvocationResult::YieldOutsideAsyncContext) => unsafe {
+                raise_lib_trap(Trap::lib(TrapCode::YieldOutsideAsyncContext))
+            },
+            Err(panic) => unsafe { resume_panic(panic) },
+        }
+    }
+
+    fn func_body_ptr(&self) -> VMFunctionCallback {
+        Self::func_wrapper as VMFunctionCallback
+    }
+
+    fn call_trampoline_address(&self) -> VMTrampoline {
+        Self::call_trampoline
+    }
+
+    unsafe extern "C" fn call_trampoline(
+        vmctx: *mut VMContext,
+        _body: VMFunctionCallback,
+        args: *mut RawValue,
+    ) {
+        // The VMFunctionCallback is null here: it is only filled in later
+        // by the engine linker.
+        unsafe {
+            let dynamic_function = &mut *(vmctx as *mut VMDynamicFunctionContext<Self>);
+            Self::func_wrapper(dynamic_function, args);
+        }
+    }
+}
+
+/// Represents a low-level Wasm static host function. See
+/// [`crate::Function::new_typed`] and
+/// [`crate::Function::new_typed_with_env`] to learn more.
+pub(crate) struct StaticFunction<F, T> {
+    pub(crate) store_id: StoreId,
+    pub(crate) env: FunctionEnv<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 ),* ) => {
+        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-unwind" 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,
+            {
+                let result = on_host_stack(|| {
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        let mut store_wrapper = unsafe { StoreContext::get_current(env.store_id) };
+                        let mut store = store_wrapper.as_mut();
+                        $(
+                            let $x = unsafe {
+                                FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x))
+                            };
+                        )*
+                        to_invocation_result((env.func)($($x),* ).into_result())
+                    }))
+                });
+
+                // 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(InvocationResult::Success(result)) => unsafe {
+                        // Note: can't acquire a proper ref-counted context ref here, since we can switch
+                        // away from the WASM stack at any time.
+                        // Safety: The pointer is only used for the duration of the call to `into_c_struct`.
+                        let mut store_wrapper = StoreContext::get_current_transient(env.store_id);
+                        let mut store = store_wrapper.as_mut().unwrap();
+                        return result.into_c_struct(store);
+                    },
+                    Ok(InvocationResult::Exception(exception)) => unsafe {
+                        // Note: can't acquire a proper ref-counted context ref here, since we can switch
+                        // away from the WASM stack at any time.
+                        // Safety: The pointer is only used for the duration of the call to `throw`.
+                        let mut store_wrapper = StoreContext::get_current_transient(env.store_id);
+                        let mut store = store_wrapper.as_mut().unwrap();
+                        wasmer_vm::libcalls::throw(
+                            store.objects.as_sys(),
+                            exception.vm_exceptionref().as_sys().to_u32_exnref()
+                        )
+                    }
+                    Ok(InvocationResult::Trap(trap)) => unsafe { raise_user_trap(trap) },
+                    Ok(InvocationResult::YieldOutsideAsyncContext) => unsafe {
+                        raise_lib_trap(Trap::lib(TrapCode::YieldOutsideAsyncContext))
+                    },
+                    Err(panic) => unsafe { resume_panic(panic) },
+                }
+            }
+
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func > as _
+
+        }
+
+        #[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 mut _n = 0;
+
+                unsafe {
+                    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 $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 _
+
+        }
+
+        #[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-unwind" 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,
+            {
+                let result = wasmer_vm::on_host_stack(|| {
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        let mut store_wrapper = unsafe { StoreContext::get_current(env.store_id) };
+                        let mut store = store_wrapper.as_mut();
+                        $(
+                            let $x = unsafe {
+                                FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x))
+                            };
+                        )*
+                        let f_env = crate::backend::sys::function::env::FunctionEnvMut {
+                            store_mut: store,
+                            func_env: env.env.as_sys().clone(),
+                        }.into();
+                        to_invocation_result((env.func)(f_env, $($x),* ).into_result())
+                    }))
+                });
+
+                // 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(InvocationResult::Success(result)) => unsafe {
+                        // Note: can't acquire a proper ref-counted context ref here, since we can switch
+                        // away from the WASM stack at any time.
+                        // Safety: The pointer is only used for the duration of the call to `into_c_struct`.
+                        let mut store_wrapper = StoreContext::get_current_transient(env.store_id);
+                        let mut store = store_wrapper.as_mut().unwrap();
+                        return result.into_c_struct(store);
+                    },
+                    Ok(InvocationResult::Exception(exception)) => unsafe {
+                        // Note: can't acquire a proper ref-counted context ref here, since we can switch
+                        // away from the WASM stack at any time.
+                        // Safety: The pointer is only used for the duration of the call to `throw`.
+                        let mut store_wrapper = StoreContext::get_current_transient(env.store_id);
+                        let mut store = store_wrapper.as_mut().unwrap();
+                        wasmer_vm::libcalls::throw(
+                            store.objects.as_sys(),
+                            exception.vm_exceptionref().as_sys().to_u32_exnref()
+                        )
+                    }
+                    Ok(InvocationResult::Trap(trap)) => unsafe { raise_user_trap(trap) },
+                    Ok(InvocationResult::YieldOutsideAsyncContext) => unsafe {
+                        raise_lib_trap(Trap::lib(TrapCode::YieldOutsideAsyncContext))
+                    },
+                    Err(panic) => unsafe { 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,
+            ) {
+                unsafe {
+                    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.
+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/sys/typed_function.rs b/lib/api/src/backend/sys/entities/function/typed.rs
similarity index 69%
rename from lib/api/src/sys/typed_function.rs
rename to lib/api/src/backend/sys/entities/function/typed.rs
index 1ff5d252bd..8616234ca9 100644
--- a/lib/api/src/sys/typed_function.rs
+++ b/lib/api/src/backend/sys/entities/function/typed.rs
@@ -1,9 +1,13 @@
-use crate::{FromToNativeWasmType, RuntimeError, TypedFunction, WasmTypeList};
-use wasmer_types::RawValue;
-
-use crate::native_type::NativeWasmTypeInto;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::sys::engine::NativeEngineExt;
+use crate::backend::sys::engine::NativeEngineExt;
+use crate::{
+    FromToNativeWasmType, Function, NativeWasmTypeInto, RuntimeError, StoreContext, TypedFunction,
+    Value, WasmTypeList,
+    store::{AsStoreMut, AsStoreRef},
+};
+#[cfg(feature = "experimental-async")]
+use crate::{StoreAsync, store::AsStoreAsync};
+use std::future::Future;
+use wasmer_types::{FunctionType, RawValue, Type};
 
 macro_rules! impl_native_traits {
     (  $( $x:ident ),* ) => {
@@ -16,11 +20,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()
@@ -48,11 +52,20 @@ macro_rules! impl_native_traits {
                     rets_list.as_mut()
                 };
 
+                let store_id = store.objects_mut().id();
+                // Install the store into the store context
+                let store_install_guard = unsafe {
+                    StoreContext::ensure_installed(store.as_store_mut().inner as *mut _)
+                };
+
                 let mut r;
                 loop {
                     let storeref = store.as_store_ref();
                     let config = storeref.engine().tunables().vmconfig();
                     r = unsafe {
+                        // Safety: This is the intended use-case for StoreContext::pause, as
+                        // documented in the function's doc comments.
+                        let pause_guard = StoreContext::pause(store_id);
                         wasmer_vm::wasmer_call_trampoline(
                             store.as_store_ref().signal_handler(),
                             config,
@@ -73,6 +86,9 @@ macro_rules! impl_native_traits {
                     }
                     break;
                 }
+
+                drop(store_install_guard);
+
                 r?;
 
                 let num_rets = rets_list.len();
@@ -101,15 +117,47 @@ macro_rules! impl_native_traits {
                 // Ok(Rets::from_c_struct(results))
             }
 
+            /// Call the typed func asynchronously.
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            #[cfg(feature = "experimental-async")]
+            pub(crate) fn call_async_sys(
+                func: Function,
+                store: StoreAsync,
+                $( $x: $x, )*
+            ) -> impl Future<Output = Result<Rets, RuntimeError>> + 'static
+            where
+                $( $x: FromToNativeWasmType + 'static, )*
+            {
+                async move {
+                    let mut write = store.write_lock().await;
+                    let func_ty = func.ty(&mut write);
+                    let mut params_raw = [ $( $x.to_native().into_raw(&mut write) ),* ];
+                    let mut params_values = Vec::with_capacity(params_raw.len());
+                    {
+                        for (raw, ty) in params_raw.iter().zip(func_ty.params()) {
+                            unsafe {
+                                params_values.push(Value::from_raw(&mut write, *ty, *raw));
+                            }
+                        }
+                    }
+                    drop(write);
+
+                    let results = func.call_async(&store, params_values).await?;
+                    let mut write = store.write_lock().await;
+                    convert_results::<Rets>(&mut write, func_ty, &results)
+                }
+            }
+
             #[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> {
+            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()
@@ -130,11 +178,20 @@ macro_rules! impl_native_traits {
                     rets_list.as_mut()
                 };
 
+                let store_id = store.objects_mut().id();
+                // Install the store into the store context
+                let store_install_guard = unsafe {
+                    StoreContext::ensure_installed(store.as_store_mut().inner as *mut _)
+                };
+
                 let mut r;
                 loop {
                     let storeref = store.as_store_ref();
                     let config = storeref.engine().tunables().vmconfig();
                     r = unsafe {
+                        // Safety: This is the intended use-case for StoreContext::pause, as
+                        // documented in the function's doc comments.
+                        let pause_guard = StoreContext::pause(store_id);
                         wasmer_vm::wasmer_call_trampoline(
                             store.as_store_ref().signal_handler(),
                             config,
@@ -156,6 +213,9 @@ macro_rules! impl_native_traits {
                     }
                     break;
                 }
+
+                drop(store_install_guard);
+
                 r?;
 
                 let num_rets = rets_list.len();
@@ -202,9 +262,15 @@ 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
+);
+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
 );
@@ -214,3 +280,27 @@ impl_native_traits!(
 impl_native_traits!(
     A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
 );
+
+fn convert_results<Rets>(
+    store: &mut impl AsStoreMut,
+    ty: FunctionType,
+    results: &[Value],
+) -> Result<Rets, RuntimeError>
+where
+    Rets: WasmTypeList,
+{
+    if results.len() != ty.results().len() {
+        return Err(RuntimeError::new("result arity mismatch"));
+    }
+    let mut raw_array = Rets::empty_array();
+    for ((slot, value_ty), value) in raw_array
+        .as_mut()
+        .iter_mut()
+        .zip(ty.results().iter())
+        .zip(results.iter())
+    {
+        debug_assert_eq!(value.ty(), *value_ty);
+        *slot = value.as_raw(store);
+    }
+    unsafe { Ok(Rets::from_array(store, raw_array)) }
+}
diff --git a/lib/api/src/sys/externals/global.rs b/lib/api/src/backend/sys/entities/global.rs
similarity index 63%
rename from lib/api/src/sys/externals/global.rs
rename to lib/api/src/backend/sys/entities/global.rs
index 8d43e80f08..8d3b8754e9 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,28 +35,31 @@ 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"));
         }
-        let global = self.handle.get_mut(store.objects_mut());
+        let global = self.handle.get_mut(store.objects_mut().as_sys_mut());
         if global.ty().mutability != Mutability::Var {
             return Err(RuntimeError::new("Attempted to set an immutable global"));
         }
@@ -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..15edc83407 100644
--- a/lib/api/src/sys/instance.rs
+++ b/lib/api/src/backend/sys/entities/instance.rs
@@ -1,33 +1,19 @@
-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::{
+    Extern, error::InstantiationError, exports::Exports, imports::Imports, module::Module,
+    store::AsStoreMut,
+};
 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>,
 }
 
-#[cfg(test)]
-mod send_test {
-    use super::*;
-
-    // Only here to statically ensure that `Instance` is `Send`.
-    // Will fail to compile otherwise.
-    #[allow(dead_code)]
-    fn instance_is_send(inst: Instance) {
-        fn is_send(t: impl Send) {
-            let _ = t;
-        }
-
-        is_send(inst);
-    }
-}
-
 impl From<wasmer_compiler::InstantiationError> for InstantiationError {
     fn from(other: wasmer_compiler::InstantiationError) -> Self {
         match other {
@@ -48,11 +34,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 +51,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 +73,35 @@ 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"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod send_test {
+    use super::*;
+
+    // Only here to statically ensure that `Instance` is `Send`.
+    // Will fail to compile otherwise.
+    #[allow(dead_code)]
+    fn instance_is_send(inst: Instance) {
+        fn is_send(t: impl Send) {
+            let _ = t;
+        }
+
+        is_send(inst);
+    }
+}
diff --git a/lib/api/src/sys/externals/memory.rs b/lib/api/src/backend/sys/entities/memory/mod.rs
similarity index 50%
rename from lib/api/src/sys/externals/memory.rs
rename to lib/api/src/backend/sys/entities/memory/mod.rs
index b61adc4ff6..ed16d22095 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,
+    BackendMemory, MemoryAccessError,
+    backend::sys::entities::{engine::NativeEngineExt, memory::MemoryView},
+    entities::store::{AsStoreMut, AsStoreRef},
+    location::{MemoryLocation, SharedMemoryOps},
+    vm::{VMExtern, VMExternMemory},
 };
 
+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 fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
-        self.handle.get(store.as_store_ref().objects()).ty()
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .ty()
     }
 
-    pub fn grow<IntoPages>(
+    pub(crate) fn size(&self, store: &impl AsStoreRef) -> Pages {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .size()
+    }
+
+    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,56 +123,58 @@ 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)?
-            .do_notify(
-                wasmer_vm::NotifyLocation {
-                    address: dst.address,
-                },
-                count,
-            );
+            .do_notify(dst.address, count);
         Ok(count)
     }
 
     fn wait(
         &self,
-        dst: crate::externals::memory::MemoryLocation,
+        dst: MemoryLocation,
         timeout: Option<std::time::Duration>,
     ) -> Result<u32, crate::AtomicsError> {
-        self.upgrade()
-            .ok_or(crate::AtomicsError::Unimplemented)?
-            .do_wait(
-                wasmer_vm::NotifyLocation {
-                    address: dst.address,
-                },
-                timeout,
-            )
-            .map_err(|e| match e {
-                wasmer_vm::WaiterError::Unimplemented => crate::AtomicsError::Unimplemented,
-                wasmer_vm::WaiterError::TooManyWaiters => crate::AtomicsError::TooManyWaiters,
-                wasmer_vm::WaiterError::AtomicsDisabled => crate::AtomicsError::AtomicsDisabled,
-                _ => crate::AtomicsError::Unimplemented,
-            })
+        // Safety: `ExpectedValue::None` has no safety requirements.
+        unsafe {
+            self.upgrade()
+                .ok_or(crate::AtomicsError::Unimplemented)?
+                .do_wait(
+                    wasmer_vm::NotifyLocation {
+                        memory_base: std::ptr::null_mut(),
+                        address: dst.address,
+                    },
+                    wasmer_vm::ExpectedValue::None,
+                    timeout,
+                )
+                .map_err(|e| match e {
+                    wasmer_vm::WaiterError::Unimplemented => crate::AtomicsError::Unimplemented,
+                    wasmer_vm::WaiterError::TooManyWaiters => crate::AtomicsError::TooManyWaiters,
+                    wasmer_vm::WaiterError::AtomicsDisabled => crate::AtomicsError::AtomicsDisabled,
+                    _ => crate::AtomicsError::Unimplemented,
+                })
+        }
     }
 
     fn disable_atomics(&self) -> Result<(), MemoryError> {
@@ -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)
@@ -260,51 +284,88 @@ impl<'a> MemoryBuffer<'a> {
 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)]
+        #[repr(C, packed)]
         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>();
-    }
 
-    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);
+        unsafe {
+            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>();
+        }
     }
-    if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+
+    unsafe {
+        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)]
+        #[repr(C, packed)]
         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>();
+
+        unsafe {
+            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>();
+        }
     }
 
-    while len >= 8 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    unsafe {
+        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);
+        }
     }
-    if len >= 4 {
-        copy_one::<u32>(&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!"),
+        }
     }
-    if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+
+    /// 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!"),
+        }
     }
-    if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+
+    /// 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 93%
rename from lib/api/src/sys/externals/memory_view.rs
rename to lib/api/src/backend/sys/entities/memory/view.rs
index b1dc5e1f8d..e68c9b81e5 100644
--- a/lib/api/src/sys/externals/memory_view.rs
+++ b/lib/api/src/backend/sys/entities/memory/view.rs
@@ -1,5 +1,5 @@
-use crate::store::AsStoreRef;
 use crate::MemoryAccessError;
+use crate::store::AsStoreRef;
 use std::marker::PhantomData;
 use std::mem::MaybeUninit;
 use std::slice;
@@ -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 {
@@ -61,7 +67,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.data_unchecked_mut()
+        unsafe { self.data_unchecked_mut() }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -76,7 +82,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)
+        unsafe { 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/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 55%
rename from lib/api/src/sys/module.rs
rename to lib/api/src/backend/sys/entities/module.rs
index 3aae35d02e..97b5b561e0 100644
--- a/lib/api/src/sys/module.rs
+++ b/lib/api/src/backend/sys/entities/module.rs
@@ -1,19 +1,23 @@
+//! 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,
+    CompilationProgressCallback, 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,
+    AsStoreMut, AsStoreRef, BackendModule, IntoBytes, StoreContext,
+    backend::sys::entities::engine::NativeEngineExt, engine::AsEngineRef,
+    error::InstantiationError, vm::VMInstance,
 };
 
 #[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.
@@ -41,22 +45,44 @@ impl Module {
         unsafe { Self::from_binary_unchecked(engine, binary) }
     }
 
+    pub(crate) fn from_binary_with_progress(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+        callback: CompilationProgressCallback,
+    ) -> Result<Self, CompileError> {
+        Self::validate(engine, binary)?;
+
+        let artifact = engine
+            .as_engine_ref()
+            .engine()
+            .as_sys()
+            .compile_with_progress(binary, Some(callback))?;
+        Ok(Self::from_artifact(artifact))
+    }
+
     pub(crate) unsafe fn from_binary_unchecked(
         engine: &impl AsEngineRef,
         binary: &[u8],
     ) -> Result<Self, CompileError> {
-        let module = Self::compile(engine, binary)?;
-        Ok(module)
+        Self::compile(engine, binary)
     }
 
+    #[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,54 +98,63 @@ 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> {
         let bytes = bytes.into_bytes();
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .0
-            .deserialize_unchecked(bytes.into())?;
+
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .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> {
         let bytes = bytes.into_bytes();
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .0
-            .deserialize(bytes.into())?;
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .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
-            .deserialize_from_file_unchecked(path.as_ref())?;
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .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
-            .deserialize_from_file(path.as_ref())?;
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .as_sys()
+                .deserialize_from_file(path.as_ref())?
+        };
         Ok(Self::from_artifact(artifact))
     }
 
@@ -146,6 +181,7 @@ impl Module {
         }
         let signal_handler = store.as_store_ref().signal_handler();
         let mut store_mut = store.as_store_mut();
+        let store_ptr = store_mut.inner as *mut _;
         let (engine, objects) = store_mut.engine_and_objects_mut();
         let config = engine.tunables().vmconfig();
         unsafe {
@@ -153,11 +189,14 @@ 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(),
             )?;
 
+            let store_id = objects.id();
+            let store_install_guard = StoreContext::ensure_installed(store_ptr);
+
             // After the instance handle is created, we need to initialize
             // the data, call the start function and so. However, if any
             // of this steps traps, we still need to keep the instance alive
@@ -166,7 +205,9 @@ impl Module {
             self.artifact
                 .finish_instantiation(config, signal_handler, &mut instance_handle)?;
 
-            Ok(instance_handle)
+            drop(store_install_guard);
+
+            Ok(VMInstance::Sys(instance_handle))
         }
     }
 
@@ -175,23 +216,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 +239,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..2763b2c08c
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/store/mod.rs
@@ -0,0 +1,101 @@
+//! Data types, functions and traits for `sys` runtime's `Store` implementation.
+use crate::BackendStore;
+use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
+use wasmer_vm::TrapHandlerFn;
+use wasmer_vm::init_traps;
+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 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(_))
+    }
+}
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..0bb27b8967
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/store/obj.rs
@@ -0,0 +1,29 @@
+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!"),
+        }
+    }
+}
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..88cd08ae0d
--- /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::{
+    BackendTable, ExternRef, Function, Value,
+    backend::sys::entities::engine::NativeEngineExt,
+    entities::store::{AsStoreMut, AsStoreRef},
+    error::RuntimeError,
+    vm::{VMExtern, VMExternTable},
+};
+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(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 &mut self.0 {
+            BackendTable::Sys(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(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(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..5845251343
--- /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::{
+    AsStoreMut, AsStoreRef,
+    sys::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+};
+
+#[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 78%
rename from lib/api/src/sys/errors.rs
rename to lib/api/src/backend/sys/error.rs
index b5943bef4d..950c7b021d 100644
--- a/lib/api/src/sys/errors.rs
+++ b/lib/api/src/backend/sys/error.rs
@@ -1,5 +1,5 @@
-use crate::{LinkError, RuntimeError};
-use wasmer_vm::Trap;
+use crate::LinkError;
+use wasmer_vm::{Trap, VMExceptionRef};
 
 impl From<wasmer_compiler::LinkError> for LinkError {
     fn from(other: wasmer_compiler::LinkError) -> Self {
@@ -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..4e8ea874b7
--- /dev/null
+++ b/lib/api/src/backend/sys/mod.rs
@@ -0,0 +1,29 @@
+//! Data types, functions and traits for the `sys` runtime.
+
+#[cfg(feature = "experimental-async")]
+pub(crate) mod async_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::{
+    CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware, wasmparser,
+};
+
+pub use wasmer_compiler::{Artifact, EngineBuilder, Features, Tunables};
+
+pub use wasmer_types::MiddlewareError;
+pub use wasmer_types::target::{Architecture, CpuFeature, OperatingSystem, Target, Triple};
+
+#[cfg(feature = "cranelift")]
+pub use wasmer_compiler_cranelift::{Cranelift, CraneliftOptLevel};
+#[cfg(feature = "llvm")]
+pub use wasmer_compiler_llvm::{LLVM, LLVMOptLevel};
+#[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 94%
rename from lib/api/src/sys/tunables.rs
rename to lib/api/src/backend/sys/tunables.rs
index 45f9225adf..232de0c60a 100644
--- a/lib/api/src/sys/tunables.rs
+++ b/lib/api/src/backend/sys/tunables.rs
@@ -6,9 +6,9 @@ pub use wasmer_compiler::BaseTunables;
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::TableType;
     #[allow(unused)]
     use crate::sys::NativeEngineExt;
-    use crate::TableType;
     use std::cell::UnsafeCell;
     use std::ptr::NonNull;
     use wasmer_compiler::Tunables;
@@ -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:?}"),
         }
     }
 
@@ -198,9 +198,9 @@ mod tests {
             let memory = VMTinyMemory::new().unwrap();
             // now, it's important to update vm_definition_location with the memory information!
             let mut ptr = vm_definition_location;
-            let md = ptr.as_mut();
+            let md = unsafe { ptr.as_mut() };
             let unsafecell = memory.memory_definition.as_ref().unwrap();
-            let def = unsafecell.get().as_ref().unwrap();
+            let def = unsafe { unsafecell.get().as_ref().unwrap() };
             md.base = def.base;
             md.current_length = def.current_length;
             Ok(memory.into())
@@ -221,11 +221,11 @@ mod tests {
             style: &TableStyle,
             vm_definition_location: NonNull<VMTableDefinition>,
         ) -> Result<VMTable, String> {
-            VMTable::from_definition(ty, style, vm_definition_location)
+            unsafe { VMTable::from_definition(ty, style, vm_definition_location) }
         }
 
         // 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::{Engine, Instance, Memory, Module, Store, imports};
 
         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)]
@@ -305,7 +315,7 @@ mod tests {
     ))]
     #[allow(clippy::print_stdout)]
     fn check_small_stack() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::{imports, wat2wasm, Engine, Instance, Module, Store};
+        use crate::{Engine, Instance, Module, Store, imports, wat2wasm};
         use wasmer_compiler_singlepass::Singlepass;
         // This test needs Singlepass compiler
         // because Cranelift will optimize the webassembly file
@@ -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..6e13d34a26
--- /dev/null
+++ b/lib/api/src/backend/sys/vm.rs
@@ -0,0 +1,48 @@
+//! The `vm` module re-exports wasmer-vm types.
+use crate::entities::{Function, Global, Memory, Table, Tag};
+use crate::store::AsStoreMut;
+pub use wasmer_vm::*;
+
+/// 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..73acd9b2a3
--- /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::{
+    BackendEngine,
+    backend::v8::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+};
+use std::sync::Arc;
+use wasmer_types::{Features, target::Target};
+
+// 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 {
+        Self {
+            be: BackendEngine::V8(value),
+            id: Self::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..2a11939501
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/exception.rs
@@ -0,0 +1,27 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, Tag, Value,
+    v8::vm::{VMException, VMExceptionRef},
+};
+
+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 {
+        unimplemented!("Exception handling is not yet supported in v8");
+    }
+}
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..cff3675a38
--- /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::{
+    StoreMut,
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    v8::{store::StoreHandle, vm::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_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<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, 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<'a>(&'a mut self) -> (&'a mut T, StoreMut<'a>) {
+        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 {
+        Self(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..fd5fe497e6
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/function/mod.rs
@@ -0,0 +1,724 @@
+//! 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::{
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+    v8::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+    vm::{VMExtern, VMExternFunction},
+};
+
+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
+            .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
+            .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");
+        }
+
+        Self {
+            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()
+            .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()
+            .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");
+        }
+
+        Self {
+            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()
+            .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()
+            .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");
+        }
+
+        Self {
+            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
+                .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());
+        }
+
+        let values = unsafe {
+            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
+            (*results)
+                .iter()
+                .map(|v| IntoWasmerValue::into_wv(*v))
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+        };
+        Ok(values)
+    }
+
+    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 = unsafe { (*r).store.as_store_mut() };
+        let env_handle = unsafe { (*r).env_handle.as_ref().unwrap().clone() };
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = unsafe { &(*r).func };
+
+        let mut wasmer_args = vec![];
+        let args_ptr = unsafe { (*args).data };
+        let args_len = unsafe { (*args).size };
+
+        for i in 0..args_len {
+            let value = unsafe { (*args_ptr.wrapping_add(i)).into_wv().clone() };
+            wasmer_args.push(value);
+        }
+
+        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();
+
+                let rets_size = unsafe { (*rets).size };
+                if c_results.len() != rets_size {
+                    panic!(
+                        "when calling host function: number of observed results differ from wanted results"
+                    )
+                }
+
+                let rets_ptr = unsafe { (*rets).data };
+                unsafe {
+                    let rets_slice = std::slice::from_raw_parts_mut(rets_ptr, rets_size);
+                    for (dst, value) in rets_slice.iter_mut().zip(&c_results) {
+                        *dst = *value;
+                    }
+                }
+
+                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");
+            }
+        }
+    }
+
+    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,
+            { unsafe {
+                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,
+            { unsafe {
+
+              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..092b8c7316
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/function/typed.rs
@@ -0,0 +1,153 @@
+//! 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::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+    backend::v8::{bindings::*, error::Trap, function::Function, utils::convert::*},
+};
+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..35a80fb853
--- /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::{
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+    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},
+};
+
+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..02afbfb94f
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/instance.rs
@@ -0,0 +1,150 @@
+//! Data types, functions and traits for `v8` runtime's `Function` implementation.
+use std::sync::Arc;
+
+use crate::{
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
+    backend::v8::bindings::*, v8::error::Trap, vm::VMExtern,
+};
+
+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 {
+    #[allow(clippy::result_large_err, clippy::unnecessary_mut_passed)]
+    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(Self(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<_>>();
+        exports_ty
+            .iter()
+            .zip(wasm_exports.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>()
+    }
+}
+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 {
+    #[allow(clippy::result_large_err)]
+    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: Vec<_> = module
+            .imports()
+            .map(|import_ty| {
+                imports
+                    .get_export(import_ty.module(), import_ty.name())
+                    .unwrap_or_else(|| panic!("Export {import_ty:?} not found"))
+            })
+            .collect::<Vec<_>>();
+
+        Self::new_by_index(&mut store, module, &externs)
+    }
+
+    #[allow(clippy::result_large_err)]
+    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..d73bc99f04
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/memory/mod.rs
@@ -0,0 +1,416 @@
+//! 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::{
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+    shared::SharedMemory,
+    v8::{bindings::*, vm::VMMemory},
+    vm::{VMExtern, VMExternMemory},
+};
+
+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)
+    }
+
+    /// 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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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 {
+        unsafe {
+            copy_one::<u64>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 4 {
+        unsafe {
+            copy_one::<u32>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 2 {
+        unsafe {
+            copy_one::<u16>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 1 {
+        unsafe {
+            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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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 {
+        unsafe {
+            copy_one::<u64>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 4 {
+        unsafe {
+            copy_one::<u32>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 2 {
+        unsafe {
+            copy_one::<u16>(&mut src, &mut dst, &mut len);
+        }
+    }
+    if len >= 1 {
+        unsafe {
+            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..3d516c178c 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::{
+    AsStoreRef, MemoryAccessError,
+    backend::v8::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    v8::bindings::wasm_memory_t,
+};
 
 /// 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 _) };
+        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()
+        unsafe { 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()
+        unsafe { 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..d2e8801def
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/mod.rs
@@ -0,0 +1,22 @@
+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;
+
+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..87db4d5332
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/module.rs
@@ -0,0 +1,403 @@
+//! Data types, functions and traits for `v8` runtime's `Module` implementation.
+use std::{path::Path, sync::Arc};
+
+use crate::{
+    AsEngineRef, BackendModule, IntoBytes, Store, backend::v8::bindings::*,
+    v8::utils::convert::IntoWasmerExternType,
+};
+
+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(
+                "Failed to create V8 module: null module reference returned from V8".to_string(),
+            ));
+        }
+
+        let inner = unsafe { wasm_module_share(inner) };
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(
+                "Failed to create V8 module: null module reference returned from V8".to_string(),
+            ));
+        }
+
+        Ok(Self {
+            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(
+                "Failed to deserialize V8 module: null module reference returned from V8"
+                    .to_string(),
+            ));
+        }
+
+        let inner = unsafe { wasm_module_share(inner) };
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(
+                "Failed to create V8 module: null module reference returned from V8".to_string(),
+            ));
+        }
+
+        Ok(Self {
+            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) }
+    }
+
+    #[allow(clippy::arc_with_non_send_sync)]
+    #[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())
+    }
+
+    #[allow(clippy::arc_with_non_send_sync)]
+    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> {
+        unsafe { 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())?;
+        unsafe { 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())?;
+        unsafe { 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..c821e8e871
--- /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::{
+    AsStoreRef, BackendStore, StoreRef,
+    backend::v8::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+};
+
+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();
+        Self {
+            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..fbfb0dd901
--- /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::{
+    AsStoreMut,
+    backend::v8::vm::{VMFunctionEnvironment, VMGlobal},
+};
+
+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 {
+            Self::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 {
+            Self::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 {
+            Self::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<'a>(&'a self) -> core::slice::Iter<'a, 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..d3053c221c
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/table.rs
@@ -0,0 +1,249 @@
+//! Data types, functions and traits for `v8` runtime's `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+    v8::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+    vm::{VMExtern, VMExternTable},
+};
+
+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: ty.maximum.unwrap_or_default(),
+            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(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 &mut self.0 {
+            BackendTable::V8(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(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(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..2672dfc323
--- /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::{
+    AsStoreMut, AsStoreRef,
+    v8::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoWasmerType},
+        vm::VMTag,
+    },
+    vm::{VMExtern, VMExternTag},
+};
+
+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..6065ffea37
--- /dev/null
+++ b/lib/api/src/backend/v8/error.rs
@@ -0,0 +1,163 @@
+use std::{
+    error::Error,
+    ffi::{CStr, c_char},
+};
+
+use crate::{
+    AsStoreMut,
+    v8::{bindings::*, vm::VMExceptionRef},
+};
+
+#[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,
+        }
+    }
+
+    /// Returns true if the `Trap` is an exception
+    pub fn is_exception(&self) -> bool {
+        false
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        None
+    }
+
+    #[allow(clippy::unnecessary_mut_passed)]
+    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 = unsafe { std::mem::zeroed() };
+                // let x = format!("")
+                let s1 = format!("🐛{err_ptr:p}");
+                let _s = s1.into_bytes().into_boxed_slice();
+                unsafe { wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _) };
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                unsafe { 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 = unsafe { std::mem::zeroed() };
+            unsafe { 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();
+        }
+
+        Self::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..126fd34dad
--- /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::{
+    BackendFunction, Function, Value,
+    v8::{
+        bindings::{self, *},
+        function,
+    },
+};
+
+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 {
+            Self::I32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I32 as _,
+                of: wasm_val_t__bindgen_ty_1 { i32_: val },
+            },
+            Self::I64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I64 as _,
+                of: wasm_val_t__bindgen_ty_1 { i64_: val },
+            },
+            Self::F32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F32 as _,
+                of: wasm_val_t__bindgen_ty_1 { f32_: val },
+            },
+            Self::F64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F64 as _,
+                of: wasm_val_t__bindgen_ty_1 { f64_: val },
+            },
+            Self::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) },
+                },
+            },
+            Self::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()) },
+                },
+            },
+            Self::ExternRef(_) => panic!(
+                "Creating host values from guest ExternRefs is not currently supported in V8."
+            ),
+            Self::ExceptionRef(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in V8.")
+            }
+            Self::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 _ {
+            Self::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Self::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Self::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Self::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Self::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Self::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Self::V128 => panic!("v8 currently does not support V128 types"),
+            Self::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> {
+        unsafe { (&self as *const Self).into_wextt() }
+    }
+}
+
+impl IntoWasmerExternType for *mut wasm_externtype_t {
+    unsafe fn into_wextt(self) -> Result<ExternType, String> {
+        unsafe { (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..7c798c2589
--- /dev/null
+++ b/lib/api/src/backend/v8/vm/mod.rs
@@ -0,0 +1,150 @@
+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 = ();
+
+#[allow(clippy::not_unsafe_ptr_arg_deref, clippy::unnecessary_mut_passed)]
+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 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..27fc6301fd
--- /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::{
+    BackendEngine,
+    backend::wamr::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+};
+use std::sync::Arc;
+use wasmer_types::{Features, target::Target};
+
+#[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 &mut self.be {
+            BackendEngine::Wamr(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 {
+        Self {
+            be: BackendEngine::Wamr(value),
+            id: Self::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..ef1db7b6a8
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/exception.rs
@@ -0,0 +1,27 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, Tag, Value,
+    wamr::vm::{VMException, VMExceptionRef},
+};
+
+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 {
+        unimplemented!("Exception handling is not yet supported in wamr");
+    }
+}
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..9614a6f1a6
--- /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::{
+    StoreMut,
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    wamr::{store::StoreHandle, vm::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_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(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 &mut self.0 {
+            crate::BackendFunctionEnv::Wamr(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 {
+        Self(crate::BackendFunctionEnvMut::Wamr(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        Self(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..903cbad702
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/function/mod.rs
@@ -0,0 +1,736 @@
+//! Data types, functions and traits for `wamr`'s `Function` implementation.
+
+#![allow(non_snake_case)]
+use std::{
+    ffi::c_void,
+    panic::{self, AssertUnwindSafe},
+};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+    vm::{VMExtern, VMExternFunction},
+    wamr::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+};
+
+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
+            .iter()
+            .cloned()
+            .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
+            .iter()
+            .cloned()
+            .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");
+        }
+
+        Self {
+            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 arg_types = Args::wasm_types();
+        let mut param_types = arg_types
+            .iter()
+            .cloned()
+            .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 ret_types = Rets::wasm_types();
+        let mut result_types = ret_types
+            .iter()
+            .cloned()
+            .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");
+        }
+
+        Self {
+            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 env_arg_types = Args::wasm_types();
+        let mut param_types = env_arg_types
+            .iter()
+            .cloned()
+            .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 env_ret_types = Rets::wasm_types();
+        let mut result_types = env_ret_types
+            .iter()
+            .cloned()
+            .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");
+        }
+
+        Self {
+            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
+                .iter()
+                .cloned()
+                .map(IntoCApiValue::into_cv)
+                .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());
+        }
+
+        let results_slice = unsafe { std::slice::from_raw_parts(results.data, results.size) };
+        Ok(results_slice
+            .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 = unsafe { (*r).store.as_store_mut() };
+        let env_handle = unsafe { (*r).env_handle.as_ref().unwrap().clone() };
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = unsafe { &(*r).func };
+
+        let mut wasmer_args = vec![];
+
+        for i in 0..unsafe { (*args).size } {
+            let arg = unsafe { &*(*args).data.wrapping_add(i) };
+            wasmer_args.push(arg.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();
+
+                let expected_size = unsafe { (*rets).size };
+                if c_results.len() != expected_size {
+                    panic!(
+                        "when calling host function: number of observed results differ from wanted results"
+                    )
+                }
+
+                unsafe {
+                    for (i, value) in c_results.iter().enumerate() {
+                        *(*rets).data.wrapping_add(i) = *value;
+                    }
+                }
+
+                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");
+            }
+        }
+    }
+
+    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(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 &mut self.0 {
+            BackendFunction::Wamr(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 r: *mut crate::backend::wamr::function::FunctionCallbackEnv<Func> = env as _;
+                let mut store = unsafe { (*r).store.as_store_mut() };
+                let mut i = 0;
+
+                $(
+                    let c_arg = unsafe { (*(*args).data.wrapping_add(i)).clone() };
+                    let wasmer_arg = c_arg.into_wv();
+                    let raw_arg : RawValue = wasmer_arg.as_raw(&mut store);
+                    let native_value = unsafe { $x::Native::from_raw(&mut store, raw_arg) };
+                    let $x : $x = FromToNativeWasmType::from_native(native_value);
+
+                    i += 1;
+                )*
+
+                let func = unsafe { &(*r).func };
+                let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                    func( $( $x, )* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+
+                        let types = Rets::wasm_types();
+                        let mut native_results = unsafe { result.into_array(&mut store) };
+                        let native_results = native_results.as_mut();
+
+                        let native_results: Vec<Value> = native_results
+                            .iter_mut()
+                            .enumerate()
+                            .map(|(i, r)| unsafe { Value::from_raw(&mut store, types[i], r.clone()) })
+                            .collect();
+
+                        let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                        let expected_size = unsafe { (*results).size };
+                        if c_results.len() != expected_size {
+                            panic!("when calling host function: number of observed results differ from wanted results")
+                        }
+
+                        unsafe {
+                            for (i, value) in c_results.iter().enumerate() {
+                                *(*results).data.wrapping_add(i) = *value;
+                            }
+                        }
+
+                         unsafe { std::ptr::null_mut() }
+                    },
+
+                    Ok(Err(e)) => {
+                        let trap =  crate::backend::wamr::error::Trap::user(Box::new(e));
+                        unsafe { trap.into_wasm_trap(&mut 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 mut store = unsafe { (*r).store.as_store_mut() };
+
+	          let mut i = 0;
+
+	          $(
+	          let c_arg = unsafe { (*(*args).data.wrapping_add(i)).clone() };
+	          let wasmer_arg = c_arg.into_wv();
+	          let raw_arg : RawValue = wasmer_arg.as_raw(&mut store);
+	          let native_value = unsafe { $x::Native::from_raw(&mut store, raw_arg) };
+	          let $x : $x = FromToNativeWasmType::from_native(native_value);
+
+	          i += 1;
+              )*
+
+	          let env_handle = unsafe { (*r).env_handle.as_ref().unwrap().clone() };
+	          let mut fn_env = crate::backend::wamr::function::env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+	          let func: &Func = unsafe { &(*r).func };
+
+	          let result = panic::catch_unwind(AssertUnwindSafe(|| {
+	              func(BackendFunctionEnvMut::Wamr(fn_env).into(), $( $x, )* ).into_result()
+	          }));
+
+
+	          match result {
+	              Ok(Ok(result)) => {
+	          	  let types = Rets::wasm_types();
+	          	  let mut native_results = unsafe { result.into_array(&mut store) };
+	          	  let native_results = native_results.as_mut();
+
+	          let native_results: Vec<Value> = native_results
+	              .iter_mut()
+	              .enumerate()
+	              .map(|(i, r)| unsafe {
+	           	  Value::from_raw(&mut store, types[i], r.clone())
+	           	})
+	              .collect();
+
+	          	  let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+	          	  let expected_size = unsafe { (*results).size };
+	          	  if c_results.len() != expected_size {
+	          	      panic!("when calling host function: number of observed results differ from wanted results")
+	          	  }
+
+	          	  unsafe {
+	          	      for (i, value) in c_results.iter().enumerate() {
+	          	          *(*results).data.wrapping_add(i) = *value;
+	          	      }
+
+	          	  }
+
+	          	  unsafe { std::ptr::null_mut() }
+	            },
+
+	            Ok(Err(e)) => { let trap = crate::backend::wamr::error::Trap::user(Box::new(e)); unsafe { trap.into_wasm_trap(&mut 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..388db3d690
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/function/typed.rs
@@ -0,0 +1,153 @@
+//! 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::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+    backend::wamr::{bindings::*, error::Trap, function::Function, utils::convert::*},
+};
+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..7d7efd9c1b
--- /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::{
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+    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,
+    },
+};
+
+#[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..188c5bccb4
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/instance.rs
@@ -0,0 +1,188 @@
+//! Data types, functions and traits for `wamr`'s `Instance` implementation.
+use std::sync::Arc;
+
+use crate::entities::external::VMExternToExtern;
+use crate::{
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
+    backend::wamr::bindings::*, vm::VMExtern, wamr::error::Trap,
+};
+
+#[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 {
+    #[allow(clippy::result_large_err)]
+    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, &imports, &mut trap)
+        };
+
+        if instance.is_null() {
+            let trap = Trap::from(trap);
+            return Err(InstantiationError::Start(trap.into()));
+        }
+
+        Ok(Self(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 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)
+            .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())
+                .unwrap_or_else(|_| panic!("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 {
+    #[allow(clippy::result_large_err)]
+    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();
+
+        Self::new_by_index(&mut store, module, &externs)
+    }
+
+    #[allow(clippy::result_large_err)]
+    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/backend/wamr/entities/memory/mod.rs b/lib/api/src/backend/wamr/entities/memory/mod.rs
new file mode 100644
index 0000000000..ecd177f4d4
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/memory/mod.rs
@@ -0,0 +1,357 @@
+//! 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 crate::{
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+    shared::SharedMemory,
+    vm::{VMExtern, VMExternMemory},
+    wamr::{bindings::*, vm::VMMemory},
+};
+
+pub(crate) mod view;
+pub use view::*;
+
+#[derive(Debug, Clone)]
+/// A WebAssembly `memory` in `wamr`.
+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 }));
+
+        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 { handle: memory }
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Wamr(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: 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,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        unimplemented!(
+            "calling grow from host is not supported! Use the memory.grow opcode instead."
+        );
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        unimplemented!(
+            "calling grow from host is not supported! Use the memory.grow opcode instead."
+        );
+    }
+
+    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_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> {
+        Ok(self.handle)
+    }
+
+    /// 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(C, packed)]
+        struct Unaligned<T>(T);
+        let val = unsafe { (*src as *const Unaligned<T>).read_volatile() };
+        unsafe { (*dst as *mut Unaligned<T>).write(val) };
+        *src = unsafe { src.add(std::mem::size_of::<T>()) };
+        *dst = unsafe { dst.add(std::mem::size_of::<T>()) };
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 4 {
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 2 {
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 1 {
+        unsafe { 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(C, packed)]
+        struct Unaligned<T>(T);
+        let val = unsafe { (*src as *const Unaligned<T>).read() };
+        unsafe { (*dst as *mut Unaligned<T>).write_volatile(val) };
+        *src = unsafe { src.add(std::mem::size_of::<T>()) };
+        *dst = unsafe { dst.add(std::mem::size_of::<T>()) };
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 4 {
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 2 {
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 1 {
+        unsafe { 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(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 &mut self.0 {
+            BackendMemory::Wamr(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..e9678e8753
--- /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::{
+    AsStoreRef, MemoryAccessError,
+    backend::wamr::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    wamr::bindings::wasm_memory_t,
+};
+
+/// 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 _) };
+        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] {
+        unsafe { 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] {
+        unsafe { 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..830c7d8709
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/module.rs
@@ -0,0 +1,208 @@
+//! Data types, functions and traits for `wamr`'s `Module` implementation.
+use std::{path::Path, sync::Arc};
+
+use crate::{AsEngineRef, BackendModule, IntoBytes, backend::wamr::bindings::*};
+
+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>,
+}
+
+unsafe impl Send for ModuleHandle {}
+unsafe impl Sync for ModuleHandle {}
+
+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("module is null".to_string()));
+        }
+
+        Ok(Self { 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> {
+        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> {
+        unsafe { Self::deserialize(engine, bytes) }
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::from_binary(engine, &bytes.into_bytes()).map_err(DeserializeError::Compiler)
+    }
+
+    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())?;
+        unsafe { 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())?;
+        unsafe { 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(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 &mut self.0 {
+            BackendModule::Wamr(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..cc18d07cc8
--- /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::{
+    AsStoreRef, BackendStore, StoreRef,
+    backend::wamr::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+};
+
+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) };
+        Self { 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..bf24fb7a34
--- /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::{
+    AsStoreMut,
+    backend::wamr::vm::{VMFunctionEnvironment, VMGlobal},
+};
+
+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 {
+            Self::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 {
+            Self::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 {
+            Self::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..740b5df373
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/table.rs
@@ -0,0 +1,231 @@
+//! Data types, functions and traits for `wamr`'s `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
+    vm::{VMExtern, VMExternTable},
+    wamr::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+};
+
+#[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: ty.maximum.unwrap_or_default(),
+        }));
+
+        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(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 &mut self.0 {
+            BackendTable::Wamr(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(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(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..def86e2c94
--- /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::{
+    AsStoreMut, AsStoreRef,
+    vm::{VMExtern, VMExternTag},
+    wamr::vm::VMTag,
+};
+
+#[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..5d80a671e3
--- /dev/null
+++ b/lib/api/src/backend/wamr/error.rs
@@ -0,0 +1,184 @@
+use std::{
+    error::Error,
+    ffi::{CStr, c_char},
+};
+
+use crate::{
+    AsStoreMut,
+    wamr::{bindings::*, vm::VMExceptionRef},
+};
+
+#[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,
+        }
+    }
+
+    /// Returns true if the `Trap` is an exception
+    pub fn is_exception(&self) -> bool {
+        false
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        None
+    }
+
+    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 = unsafe { std::mem::zeroed() };
+                // let x = format!("")
+                let s1 = format!("🐛{err_ptr:p}");
+                let _s = s1.into_bytes().into_boxed_slice();
+                unsafe { wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _) };
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                unsafe { wasm_trap_new(store.inner.store.as_wamr().inner, &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()
+        };
+
+        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");
+                let raw_ptr = usize::from_str_radix(r, 16).unwrap()
+                    as *const Box<dyn Error + Send + Sync + 'static>;
+                std::ptr::read(raw_ptr)
+            };
+
+            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 message = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    let out = &mut vec as *mut _;
+                    wasm_trap_message(*value, out);
+                    let cstr = CStr::from_ptr((*out).data);
+                    cstr.to_str().unwrap().to_string()
+                };
+                write!(f, "wasm-c-api trap: {message}")
+            }
+        }
+    }
+}
+
+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 message = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    let out = &mut vec as *mut _;
+                    wasm_trap_message(*value, out);
+                    let cstr = CStr::from_ptr((*out).data);
+                    cstr.to_str().unwrap().to_string()
+                };
+                write!(f, "wasm-c-api trap: {message}")
+            }
+        }
+    }
+}
+
+impl From<Trap> for crate::RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        Self::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..8aa8c39369
--- /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::{
+    BackendFunction, Function, Value,
+    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,
+    },
+};
+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 {
+            Self::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 },
+            },
+            Self::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 },
+            },
+            Self::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 },
+            },
+            Self::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 },
+            },
+            Self::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) },
+                },
+            },
+            Self::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()) },
+                },
+            },
+            Self::ExternRef(_) => panic!(
+                "Creating host values from guest ExternRefs is not currently supported in wamr ."
+            ),
+            Self::ExceptionRef(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in wamr.")
+            }
+            Self::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 _ {
+            Self::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Self::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Self::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Self::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Self::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Self::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Self::V128 => bindings::wasm_valkind_enum_WASM_V128 as _,
+            Self::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..87ccd91e9a
--- /dev/null
+++ b/lib/api/src/backend/wamr/vm/mod.rs
@@ -0,0 +1,148 @@
+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 std::ptr::NonNull;
+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 ptr =
+            NonNull::new(self).expect("The wasm-c-api returned a null pointer for wasm_extern_t");
+        let raw = ptr.as_ptr();
+        let kind = unsafe { wasm_extern_kind(raw as *const _) };
+
+        match kind as u32 {
+            0 => {
+                let func = unsafe { wasm_extern_as_func(raw) };
+                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(raw) };
+                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(raw) };
+                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(raw) };
+                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..a3e9054769
--- /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::{
+    BackendEngine,
+    backend::wasmi::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+};
+use std::sync::Arc;
+use wasmer_types::{Features, target::Target};
+
+#[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 &mut self.be {
+            BackendEngine::Wasmi(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 {
+        Self {
+            be: BackendEngine::Wasmi(value),
+            id: Self::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..1de3579564
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/exception.rs
@@ -0,0 +1,27 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, Tag, Value,
+    wasmi::vm::{VMException, VMExceptionRef},
+};
+
+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 {
+        unimplemented!("Exception handling is not yet supported in wasmi");
+    }
+}
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..04e691d96d
--- /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::{
+    StoreMut,
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    wasmi::{store::StoreHandle, vm::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_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<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, 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<'a>(&'a mut self) -> (&'a mut T, StoreMut<'a>) {
+        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(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 &mut self.0 {
+            crate::BackendFunctionEnv::Wasmi(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 {
+        Self(crate::BackendFunctionEnvMut::Wasmi(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        Self(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..7526fd56b2
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/function/mod.rs
@@ -0,0 +1,738 @@
+//! Data types, functions and traits for `wasmi`'s `Function` implementation.
+
+#![allow(non_snake_case)]
+use std::{
+    ffi::c_void,
+    panic::{self, AssertUnwindSafe},
+};
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+    vm::{VMExtern, VMExternFunction},
+    wasmi::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+};
+
+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
+            .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
+            .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");
+        }
+
+        Self {
+            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()
+            .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()
+            .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");
+        }
+
+        Self {
+            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()
+            .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()
+            .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");
+        }
+
+        Self {
+            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
+                    .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());
+        }
+
+        let values = unsafe {
+            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
+            (*results)
+                .iter()
+                .map(|v| IntoWasmerValue::into_wv(*v))
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+        };
+        Ok(values)
+    }
+
+    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 = unsafe { (*r).store.as_store_mut() };
+        let env_handle = unsafe { (*r).env_handle.as_ref().unwrap().clone() };
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = unsafe { &(*r).func };
+
+        let mut wasmer_args = vec![];
+        let args_ptr = unsafe { (*args).data };
+        let args_len = unsafe { (*args).size };
+
+        for i in 0..args_len {
+            let value = unsafe { (*args_ptr.wrapping_add(i)).into_wv().clone() };
+            wasmer_args.push(value);
+        }
+
+        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();
+
+                let rets_size = unsafe { (*rets).size };
+                if c_results.len() != rets_size {
+                    panic!(
+                        "when calling host function: number of observed results differ from wanted results"
+                    )
+                }
+
+                let rets_ptr = unsafe { (*rets).data };
+                unsafe {
+                    let rets_slice = std::slice::from_raw_parts_mut(rets_ptr, rets_size);
+                    for (dst, value) in rets_slice.iter_mut().zip(&c_results) {
+                        *dst = *value;
+                    }
+                }
+
+                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");
+            }
+        }
+    }
+
+    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(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 &mut self.0 {
+            BackendFunction::Wasmi(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 = unsafe { &mut (*r).store.as_store_mut() };
+                let mut i = 0;
+                let args_ptr = unsafe { (*args).data };
+
+                $(
+                    let c_arg = unsafe { (*args_ptr.wrapping_add(i)).clone() };
+                    let wasmer_arg = c_arg.into_wv();
+                    let raw_arg : RawValue = wasmer_arg.as_raw(store);
+                    let native_value = unsafe { $x::Native::from_raw(store, raw_arg) };
+                    let $x : $x = FromToNativeWasmType::from_native(native_value);
+
+                    i += 1;
+                )*
+
+                let func = unsafe { &(*r).func };
+                let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                    (func)( $( $x, )* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+
+                        let types = Rets::wasm_types();
+                        let mut native_results = unsafe { result.into_array(store) };
+                        let native_results = native_results.as_mut();
+
+                        let native_results: Vec<Value> = native_results.iter().enumerate()
+                            .map(|(i, r)| unsafe { 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();
+                        let results_len = unsafe { (*results).size };
+                        if c_results.len() != results_len {
+                            panic!("when calling host function: number of observed results differ from wanted results")
+                        }
+
+                        let results_ptr = unsafe { (*results).data };
+                        unsafe {
+                            let results_slice =
+                                std::slice::from_raw_parts_mut(results_ptr, results_len);
+                            for (dst, value) in results_slice.iter_mut().zip(&c_results) {
+                                *dst = *value;
+                            }
+                        }
+
+                         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 = unsafe { &mut (*r).store.as_store_mut() };
+
+              let mut i = 0;
+              let args_ptr = unsafe { (*args).data };
+
+              $(
+              let c_arg = unsafe { (*args_ptr.wrapping_add(i)).clone() };
+              let wasmer_arg = c_arg.into_wv();
+              let raw_arg : RawValue = wasmer_arg.as_raw(store);
+              let native_value = unsafe { $x::Native::from_raw(store, raw_arg) };
+              let $x : $x = FromToNativeWasmType::from_native(native_value);
+
+              i += 1;
+              )*
+
+              let env_handle = unsafe { (*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 = unsafe { &(*r).func };
+
+              let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                  (func)(BackendFunctionEnvMut::Wasmi(fn_env).into(), $( $x, )* ).into_result()
+              }));
+
+
+              match result {
+                  Ok(Ok(result)) => {
+                    let types = Rets::wasm_types();
+                    let mut native_results = unsafe { result.into_array(store) };
+                    let native_results = native_results.as_mut();
+
+                    let native_results: Vec<Value> = native_results.iter().enumerate().map(|(i, r)| unsafe { 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();
+                    let results_len = unsafe { (*results).size };
+                    if c_results.len() != results_len {
+                        panic!("when calling host function: number of observed results differ from wanted results")
+                    }
+
+                    let results_ptr = unsafe { (*results).data };
+                    unsafe {
+                        let results_slice =
+                            std::slice::from_raw_parts_mut(results_ptr, results_len);
+                        for (dst, value) in results_slice.iter_mut().zip(&c_results) {
+                            *dst = *value;
+                        }
+                    }
+
+                    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..63972edfd9
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/function/typed.rs
@@ -0,0 +1,151 @@
+//! 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::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+    backend::wasmi::{bindings::*, error::Trap, function::Function, utils::convert::*},
+};
+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..393bb61e78
--- /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::{
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+    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,
+    },
+};
+
+#[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..72765dc3e5
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/instance.rs
@@ -0,0 +1,168 @@
+//! Data types, functions and traits for `wasmi`'s `Instance` implementation.
+use std::sync::Arc;
+
+use crate::{
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
+    backend::wasmi::bindings::*, entities::external::VMExternToExtern, vm::VMExtern,
+    wasmi::error::Trap,
+};
+
+#[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 {
+    #[allow(clippy::result_large_err, clippy::unnecessary_mut_passed)]
+    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(Self(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)
+            .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 {
+    #[allow(clippy::result_large_err)]
+    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<_>>();
+
+        Self::new_by_index(store, module, &externs)
+    }
+
+    #[allow(clippy::result_large_err)]
+    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..db0858db64
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/memory/mod.rs
@@ -0,0 +1,376 @@
+//! 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::{
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+    shared::SharedMemory,
+    vm::{VMExtern, VMExternMemory},
+    wasmi::{bindings::*, vm::VMMemory},
+};
+
+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)
+    }
+
+    /// 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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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 {
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 4 {
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 2 {
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 1 {
+        unsafe { 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(C, packed)]
+        struct Unaligned<T>(T);
+        unsafe {
+            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 {
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 4 {
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 2 {
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
+    }
+    if len >= 1 {
+        unsafe { 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(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 &mut self.0 {
+            BackendMemory::Wasmi(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..90b17d6800
--- /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::{
+    AsStoreRef, MemoryAccessError,
+    backend::wasmi::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    wasmi::bindings::wasm_memory_t,
+};
+
+/// 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 _) };
+        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] {
+        unsafe { std::slice::from_raw_parts(self.buffer.base as *const u8, self.buffer.len) }
+    }
+
+    /// 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] {
+        unsafe { 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..a0b5d98241
--- /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::{
+    AsEngineRef, BackendModule, IntoBytes,
+    backend::wasmi::bindings::{
+        wasm_byte_vec_t, wasm_module_delete, wasm_module_new, wasm_module_t,
+    },
+};
+
+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("module is null".to_string()));
+        }
+
+        Ok(Self { 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) }
+    }
+
+    #[allow(clippy::arc_with_non_send_sync)]
+    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> {
+        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> {
+        unsafe { Self::deserialize(engine, bytes) }
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::from_binary(engine, &bytes.into_bytes()).map_err(DeserializeError::Compiler)
+    }
+
+    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())?;
+        unsafe { 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())?;
+        unsafe { 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(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 &mut self.0 {
+            BackendModule::Wasmi(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..d27503ae74
--- /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::{
+    AsStoreRef, BackendStore, StoreRef,
+    backend::wasmi::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+};
+
+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) };
+        Self { 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..3ee18e5bfe
--- /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::{
+    AsStoreMut,
+    backend::wasmi::vm::{VMFunctionEnvironment, VMGlobal},
+};
+
+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 {
+            Self::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 {
+            Self::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 {
+            Self::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<'a>(&'a self) -> core::slice::Iter<'a, 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..cb8f3b354d
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/table.rs
@@ -0,0 +1,230 @@
+//! Data types, functions and traits for `wasmi`'s `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
+    vm::{VMExtern, VMExternTable},
+    wasmi::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+};
+
+#[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: ty.maximum.unwrap_or_default(),
+        }));
+
+        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(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 &mut self.0 {
+            BackendTable::Wasmi(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(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(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..277d0322ca
--- /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::{
+    AsStoreMut, AsStoreRef,
+    vm::{VMExtern, VMExternTag},
+    wasmi::vm::VMTag,
+};
+
+#[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..02f22e61ef
--- /dev/null
+++ b/lib/api/src/backend/wasmi/error.rs
@@ -0,0 +1,183 @@
+use std::{
+    error::Error,
+    ffi::{CStr, c_char},
+};
+
+use crate::{
+    AsStoreMut,
+    wasmi::{bindings::*, vm::VMExceptionRef},
+};
+
+#[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,
+        }
+    }
+
+    /// Returns true if the `Trap` is an exception
+    pub fn is_exception(&self) -> bool {
+        false
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        None
+    }
+
+    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 = unsafe { std::mem::zeroed() };
+                // let x = format!("")
+                let s1 = format!("🐛{err_ptr:p}");
+                let _s = s1.into_bytes().into_boxed_slice();
+                unsafe {
+                    wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                }
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                unsafe { wasm_trap_new(store.inner.store.as_wasmi().inner, &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()
+        };
+
+        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();
+        }
+
+        Self::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..a1d45fcddb
--- /dev/null
+++ b/lib/api/src/backend/wasmi/utils/convert.rs
@@ -0,0 +1,149 @@
+/// Utilities to convert between `wasmi` and `wasmer` values
+use crate::{
+    BackendFunction, Function, Value,
+    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,
+    },
+};
+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 {
+            Self::I32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I32 as _,
+                of: wasm_val_t__bindgen_ty_1 { i32_: val },
+            },
+            Self::I64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I64 as _,
+                of: wasm_val_t__bindgen_ty_1 { i64_: val },
+            },
+            Self::F32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F32 as _,
+                of: wasm_val_t__bindgen_ty_1 { f32_: val },
+            },
+            Self::F64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F64 as _,
+                of: wasm_val_t__bindgen_ty_1 { f64_: val },
+            },
+            Self::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) },
+                },
+            },
+            Self::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()) },
+                },
+            },
+            Self::ExternRef(_) => panic!(
+                "Creating host values from guest ExternRefs is not currently supported in wasmi."
+            ),
+            Self::ExceptionRef(_) => panic!(
+                "Creating host values from guest ExceptionRefs is not currently supported in wasmi."
+            ),
+            Self::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 _ {
+            Self::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Self::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Self::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Self::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Self::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Self::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Self::V128 => panic!("wasmi does not support V128!"),
+            Self::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..055785fb8f
--- /dev/null
+++ b/lib/api/src/backend/wasmi/vm/mod.rs
@@ -0,0 +1,145 @@
+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 {
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        let kind = unsafe { wasm_extern_kind(self) };
+
+        match kind as u32 {
+            0 => {
+                let func = unsafe { wasm_extern_as_func(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(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(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(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 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..8edaa93d54
--- /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..f37af54f34
--- /dev/null
+++ b/lib/api/src/entities/engine/inner.rs
@@ -0,0 +1,196 @@
+use bytes::Bytes;
+use std::{path::Path, sync::Arc};
+use wasmer_types::{DeserializeError, Features, target::Target};
+
+#[cfg(feature = "sys")]
+use wasmer_compiler::Artifact;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::CompilerConfig;
+
+use crate::{
+    BackendKind, IntoBytes, Store,
+    macros::backend::{gen_rt_ty, match_rt},
+};
+
+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) => unsafe {
+                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) => unsafe { 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) => unsafe { 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) => unsafe { 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..ec2d2aa758
--- /dev/null
+++ b/lib/api/src/entities/engine/mod.rs
@@ -0,0 +1,268 @@
+//! 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::{
+    CompileError, DeserializeError, Features,
+    target::{Target, UserCompilerOptimizations},
+};
+
+#[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> {
+        unsafe { 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> {
+        unsafe { 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> {
+        unsafe { 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> {
+        unsafe { 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(()),
+        }
+    }
+
+    #[cfg(feature = "experimental-async")]
+    /// Returns true if the engine supports async operations.
+    pub fn supports_async(&self) -> bool {
+        match self.be {
+            #[cfg(feature = "sys")]
+            BackendEngine::Sys(ref e) => true,
+            _ => false,
+        }
+    }
+}
diff --git a/lib/api/src/entities/exception/inner.rs b/lib/api/src/entities/exception/inner.rs
new file mode 100644
index 0000000000..08d0344ca3
--- /dev/null
+++ b/lib/api/src/entities/exception/inner.rs
@@ -0,0 +1,90 @@
+use crate::vm::VMExceptionRef;
+use crate::{
+    AsStoreMut, AsStoreRef, BackendTag, ExportError, Exportable, Extern, Tag, Value,
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternTag},
+};
+
+/// 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]
+    #[allow(irrefutable_let_patterns)]
+    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(_) => {
+                let BackendTag::Sys(tag) = &tag.0 else {
+                    panic!("cannot create Exception with Tag from another backend");
+                };
+
+                Self::Sys(crate::backend::sys::exception::Exception::new(
+                    store, tag, payload,
+                ))
+            }
+            _ => unimplemented!("new is only implemented for the sys backend"),
+        }
+    }
+
+    /// Checks whether this `Exception` can be used with the given store.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.is_from_store(store),
+            _ => unimplemented!("is_from_store is only implemented for the sys backend"),
+        }
+    }
+
+    /// Gets the exception tag.
+    #[inline]
+    pub fn tag(&self, store: &impl AsStoreRef) -> Tag {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => Tag(BackendTag::Sys(s.tag(store))),
+            _ => unimplemented!("tag is only implemented for the sys backend"),
+        }
+    }
+
+    /// Gets the exception payload values.
+    #[inline]
+    pub fn payload(&self, store: &mut impl AsStoreMut) -> Vec<Value> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.payload(store),
+            _ => unimplemented!("payload is only implemented for the sys backend"),
+        }
+    }
+
+    /// Get the `VMExceptionRef` corresponding to this `Exception`.
+    #[inline]
+    pub fn vm_exceptionref(&self) -> VMExceptionRef {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => VMExceptionRef::Sys(s.exnref()),
+            _ => unimplemented!("vm_exceptionref is only implemented for the sys backend"),
+        }
+    }
+
+    /// Creates a new `Exception` from a `VMExceptionRef`.
+    #[inline]
+    pub fn from_vm_exceptionref(exnref: VMExceptionRef) -> Self {
+        match exnref {
+            #[cfg(feature = "sys")]
+            VMExceptionRef::Sys(s) => {
+                Self::Sys(crate::backend::sys::exception::Exception::from_exnref(s))
+            }
+            _ => unimplemented!("from_vm_exceptionref is only implemented for the sys backend"),
+        }
+    }
+}
diff --git a/lib/api/src/entities/exception/mod.rs b/lib/api/src/entities/exception/mod.rs
new file mode 100644
index 0000000000..abdc15acf7
--- /dev/null
+++ b/lib/api/src/entities/exception/mod.rs
@@ -0,0 +1,51 @@
+pub(crate) mod inner;
+pub(crate) use inner::*;
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, Tag, Value,
+    vm::{VMExceptionRef, VMExtern, VMExternTag},
+};
+
+/// 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 and payload, and also creates
+    /// a reference to it, returning the reference.
+    pub fn new(store: &mut impl AsStoreMut, tag: &Tag, payload: &[Value]) -> Self {
+        Self(BackendException::new(store, tag, payload))
+    }
+
+    /// Check whether this `Exception` comes from the given store.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    /// Get the exception tag.
+    pub fn tag(&self, store: &impl AsStoreRef) -> Tag {
+        self.0.tag(store)
+    }
+
+    /// Get the exception payload values.
+    pub fn payload(&self, store: &mut impl AsStoreMut) -> Vec<Value> {
+        self.0.payload(store)
+    }
+
+    /// Get the `VMExceptionRef` corresponding to this `Exception`.
+    pub fn vm_exceptionref(&self) -> VMExceptionRef {
+        self.0.vm_exceptionref()
+    }
+
+    /// Create an `Exception` from a `VMExceptionRef`.
+    pub fn from_vm_exceptionref(exnref: VMExceptionRef) -> Self {
+        Self(BackendException::from_vm_exceptionref(exnref))
+    }
+}
diff --git a/lib/api/src/exports.rs b/lib/api/src/entities/exports.rs
similarity index 97%
rename from lib/api/src/exports.rs
rename to lib/api/src/entities/exports.rs
index d2f821145f..5bda72891d 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>,
 }
@@ -174,7 +175,7 @@ impl Exports {
     }
 
     /// Get an iterator over the exports.
-    pub fn iter(&self) -> ExportsIterator<impl Iterator<Item = (&String, &Extern)>> {
+    pub fn iter(&self) -> ExportsIterator<'_, indexmap::map::Iter<'_, String, Extern>> {
         ExportsIterator {
             iter: self.map.iter(),
         }
@@ -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..9c974f7cda
--- /dev/null
+++ b/lib/api/src/entities/external/extref/inner.rs
@@ -0,0 +1,140 @@
+use std::any::Any;
+
+use crate::StoreRef;
+use crate::entities::store::{AsStoreMut, AsStoreRef};
+use crate::macros::backend::{gen_rt_ty, match_rt};
+use crate::vm::VMExternRef;
+
+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(unsafe {
+                crate::backend::sys::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_sys(),
+                )
+            }),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(unsafe {
+                crate::backend::wamr::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_wamr(),
+                )
+            }),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(unsafe {
+                crate::backend::wasmi::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_wasmi(),
+                )
+            }),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(unsafe {
+                crate::backend::v8::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_v8(),
+                )
+            }),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(unsafe {
+                crate::backend::js::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_js(),
+                )
+            }),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(unsafe {
+                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..6257eb2c10 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::StoreRef;
+use crate::entities::store::{AsStoreMut, AsStoreRef};
 use crate::vm::VMExternRef;
 
-#[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(unsafe { 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..7ee104f6eb 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::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Function, Global, Memory, Table, Tag,
+    vm::VMExtern,
+};
 
-#[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/async_host.rs b/lib/api/src/entities/function/async_host.rs
new file mode 100644
index 0000000000..01702a9118
--- /dev/null
+++ b/lib/api/src/entities/function/async_host.rs
@@ -0,0 +1,178 @@
+use std::{future::Future, marker::PhantomData, pin::Pin};
+
+use crate::{
+    AsyncFunctionEnvMut, HostFunctionKind, RuntimeError, WasmTypeList, WithEnv, WithoutEnv,
+    utils::{FromToNativeWasmType, IntoResult},
+};
+
+/// Wrapper conveying whether an async host function receives an environment.
+pub enum AsyncFunctionEnv<T, Kind> {
+    /// Used by host functions without an environment.
+    WithoutEnv(PhantomData<(T, Kind)>),
+    /// Used by host functions that capture an environment.
+    WithEnv(AsyncFunctionEnvMut<T>),
+}
+
+impl<T> AsyncFunctionEnv<T, WithoutEnv> {
+    /// Create an environment wrapper for functions without host state.
+    pub fn new() -> Self {
+        Self::WithoutEnv(PhantomData)
+    }
+}
+
+impl<T> AsyncFunctionEnv<T, WithEnv> {
+    /// Create an environment wrapper carrying [`AsyncFunctionEnvMut`].
+    pub fn with_env(env: AsyncFunctionEnvMut<T>) -> Self {
+        Self::WithEnv(env)
+    }
+
+    /// Extract the underlying [`AsyncFunctionEnvMut`].
+    pub fn into_env(self) -> AsyncFunctionEnvMut<T> {
+        match self {
+            Self::WithEnv(env) => env,
+            Self::WithoutEnv(_) => unreachable!("with-env async function called without env"),
+        }
+    }
+}
+
+/// Async counterpart to [`HostFunction`](super::host::HostFunction).
+pub trait AsyncHostFunction<T, Args, Rets, Kind>
+where
+    Args: WasmTypeList + 'static,
+    Rets: WasmTypeList,
+    Kind: HostFunctionKind,
+{
+    /// Invoke the host function asynchronously.
+    fn call_async(
+        &self,
+        env: AsyncFunctionEnv<T, Kind>,
+        args: Args,
+    ) -> Pin<Box<dyn Future<Output = Result<Rets, RuntimeError>>>>;
+}
+
+macro_rules! impl_async_host_function_without_env {
+    ( $( $x:ident ),* ) => {
+        impl<$( $x, )* Rets, RetsAsResult, F, Fut > AsyncHostFunction<(), ( $( $x ),* ), Rets, WithoutEnv> for F
+        where
+            F: Fn($( $x ),*) -> Fut + 'static,
+            Fut: Future<Output = RetsAsResult> + 'static,
+            RetsAsResult: IntoResult<Rets>,
+            Rets: WasmTypeList,
+            ( $( $x ),* ): WasmTypeList + 'static,
+            $( $x: FromToNativeWasmType + 'static, )*
+        {
+            fn call_async(
+                &self,
+                _env: AsyncFunctionEnv<(), WithoutEnv>,
+                args: ( $( $x ),* ),
+            ) -> Pin<Box<dyn Future<Output = Result<Rets, RuntimeError>>>> {
+                #[allow(non_snake_case)]
+                let ( $( $x ),* ) = args;
+                let fut = (self)( $( $x ),* );
+                Box::pin(async move {
+                    fut.await
+                        .into_result()
+                        .map_err(|err| RuntimeError::from_dyn(Box::new(err)))
+                })
+            }
+        }
+    };
+}
+
+macro_rules! impl_async_host_function_with_env {
+    ( $( $x:ident ),* ) => {
+        impl<$( $x, )* Rets, RetsAsResult,  T, F, Fut > AsyncHostFunction<T, ( $( $x ),* ), Rets, WithEnv> for F
+        where
+            T: 'static,
+            F: Fn(AsyncFunctionEnvMut<T>, $( $x ),*) -> Fut + 'static,
+            Fut: Future<Output = RetsAsResult> + 'static,
+            RetsAsResult: IntoResult<Rets>,
+            Rets: WasmTypeList,
+            ( $( $x ),* ): WasmTypeList + 'static,
+            $( $x: FromToNativeWasmType + 'static, )*
+        {
+            fn call_async(
+                &self,
+                env: AsyncFunctionEnv<T, WithEnv>,
+                args: ( $( $x ),* ),
+            ) -> Pin<Box<dyn Future<Output = Result<Rets, RuntimeError>>>> {
+                #[allow(non_snake_case)]
+                let ( $( $x ),* ) = args;
+                let fut = (self)(env.into_env(), $( $x ),* );
+                Box::pin(async move {
+                    fut.await
+                        .into_result()
+                        .map_err(|err| RuntimeError::from_dyn(Box::new(err)))
+                })
+            }
+        }
+    };
+}
+
+impl_async_host_function_without_env!();
+impl_async_host_function_without_env!(A1);
+impl_async_host_function_without_env!(A1, A2);
+impl_async_host_function_without_env!(A1, A2, A3);
+impl_async_host_function_without_env!(A1, A2, A3, A4);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_async_host_function_without_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
+);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16
+);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17
+);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_async_host_function_without_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
+
+impl_async_host_function_with_env!();
+impl_async_host_function_with_env!(A1);
+impl_async_host_function_with_env!(A1, A2);
+impl_async_host_function_with_env!(A1, A2, A3);
+impl_async_host_function_with_env!(A1, A2, A3, A4);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_async_host_function_with_env!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_async_host_function_with_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
+);
+impl_async_host_function_with_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16
+);
+impl_async_host_function_with_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17
+);
+impl_async_host_function_with_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_async_host_function_with_env!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_async_host_function_with_env!(
+    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/entities/function/env/inner.rs b/lib/api/src/entities/function/env/inner.rs
new file mode 100644
index 0000000000..e1b576623b
--- /dev/null
+++ b/lib/api/src/entities/function/env/inner.rs
@@ -0,0 +1,594 @@
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
+use crate::{
+    AsStoreMut, AsStoreRef, FunctionEnv, FunctionEnvMut, StoreMut, StoreRef,
+    macros::backend::match_rt,
+};
+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),
+            ),
+        }
+    }
+
+    /// 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(f) => BackendFunctionEnv::Sys(f.as_ref()).into(),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(f) => BackendFunctionEnv::Wamr(f.as_ref()).into(),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(f) => BackendFunctionEnv::Wasmi(f.as_ref()).into(),
+            #[cfg(feature = "v8")]
+            Self::V8(f) => BackendFunctionEnv::V8(f.as_ref()).into(),
+            #[cfg(feature = "js")]
+            Self::Js(f) => BackendFunctionEnv::Js(f.as_ref()).into(),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(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(f) => BackendFunctionEnvMut::Sys(f.as_mut()).into(),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(f) => BackendFunctionEnvMut::Wamr(f.as_mut()).into(),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(f) => BackendFunctionEnvMut::Wasmi(f.as_mut()).into(),
+            #[cfg(feature = "v8")]
+            Self::V8(f) => BackendFunctionEnvMut::V8(f.as_mut()).into(),
+            #[cfg(feature = "js")]
+            Self::Js(f) => BackendFunctionEnvMut::Js(f.as_mut()).into(),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(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()
+        })
+    }
+
+    /// Creates an [`AsStoreAsync`] from this [`BackendFunctionEnvMut`] if the current
+    /// context is async.
+    #[cfg(feature = "experimental-async")]
+    pub fn as_store_async(&self) -> Option<impl AsStoreAsync + 'static> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.as_store_async(),
+            #[cfg(feature = "sys")]
+            _ => unsupported_async_backend(),
+            #[cfg(not(feature = "sys"))]
+            _ => unsupported_async_backend::<Option<crate::StoreAsync>>(),
+        }
+    }
+}
+
+impl<T> AsStoreRef for BackendFunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        match_rt!(on self => s {
+            s.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:?}")
+        })
+    }
+}
+
+/// A shared handle to a [`FunctionEnv`], suitable for use
+/// in async imports.
+#[derive(derive_more::From)]
+#[cfg(feature = "experimental-async")]
+pub enum BackendAsyncFunctionEnvMut<T> {
+    #[cfg(feature = "sys")]
+    /// The function environment for the `sys` runtime.
+    Sys(crate::backend::sys::function::env::AsyncFunctionEnvMut<T>),
+    #[cfg(any(
+        feature = "wamr",
+        feature = "wasmi",
+        feature = "v8",
+        feature = "js",
+        feature = "jsc"
+    ))]
+    /// Placeholder for unsupported backends.
+    Unsupported(PhantomData<T>),
+}
+
+/// A read-only handle to the [`FunctionEnv`] in an [`BackendAsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub enum BackendAsyncFunctionEnvHandle<T> {
+    #[cfg(feature = "sys")]
+    /// The function environment handle for the `sys` runtime.
+    Sys(crate::backend::sys::function::env::AsyncFunctionEnvHandle<T>),
+    #[cfg(any(
+        feature = "wamr",
+        feature = "wasmi",
+        feature = "v8",
+        feature = "js",
+        feature = "jsc"
+    ))]
+    /// Placeholder for unsupported backends.
+    Unsupported(PhantomData<T>),
+}
+
+/// A mutable handle to the [`FunctionEnv`] in an [`BackendAsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub enum BackendAsyncFunctionEnvHandleMut<T> {
+    #[cfg(feature = "sys")]
+    /// The function environment handle for the `sys` runtime.
+    Sys(crate::backend::sys::function::env::AsyncFunctionEnvHandleMut<T>),
+    #[cfg(any(
+        feature = "wamr",
+        feature = "wasmi",
+        feature = "v8",
+        feature = "js",
+        feature = "jsc"
+    ))]
+    /// Placeholder for unsupported backends.
+    Unsupported(PhantomData<T>),
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> BackendAsyncFunctionEnvMut<T> {
+    /// Waits for a store lock and returns a read-only handle to the
+    /// function environment.
+    pub async fn read(&self) -> BackendAsyncFunctionEnvHandle<T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => BackendAsyncFunctionEnvHandle::Sys(f.read().await),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Waits for a store lock and returns a mutable handle to the
+    /// function environment.
+    pub async fn write(&self) -> BackendAsyncFunctionEnvHandleMut<T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => BackendAsyncFunctionEnvHandleMut::Sys(f.write().await),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Borrows a new immutable reference
+    pub fn as_ref(&self) -> BackendFunctionEnv<T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => BackendFunctionEnv::Sys(f.as_ref()),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> Self {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => Self::Sys(f.as_mut()),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Creates an [`AsStoreAsync`] from this [`BackendAsyncFunctionEnvMut`].
+    pub fn as_store_async(&self) -> impl AsStoreAsync + 'static {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.as_store_async(),
+            #[cfg(all(
+                feature = "sys",
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend(),
+            #[cfg(all(
+                not(feature = "sys"),
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend::<crate::StoreAsync>(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> BackendAsyncFunctionEnvHandle<T> {
+    /// Returns a reference to the host state in this function environment.
+    pub fn data(&self) -> &T {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.data(),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Returns both the host state and the attached StoreRef
+    pub fn data_and_store(&self) -> (&T, &impl AsStoreRef) {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.data_and_store(),
+            #[cfg(all(
+                feature = "sys",
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend(),
+            #[cfg(all(
+                not(feature = "sys"),
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend::<(&T, &StoreRef)>(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for BackendAsyncFunctionEnvHandle<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => AsStoreRef::as_store_ref(f),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> BackendAsyncFunctionEnvHandleMut<T> {
+    /// Returns a mutable reference to the host state in this function environment.
+    pub fn data_mut(&mut self) -> &mut T {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.data_mut(),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    /// Returns both the host state and the attached StoreMut
+    pub fn data_and_store_mut(&mut self) -> (&mut T, &mut impl AsStoreMut) {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.data_and_store_mut(),
+            #[cfg(all(
+                feature = "sys",
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend(),
+            #[cfg(all(
+                not(feature = "sys"),
+                any(
+                    feature = "wamr",
+                    feature = "wasmi",
+                    feature = "v8",
+                    feature = "js",
+                    feature = "jsc"
+                )
+            ))]
+            _ => unsupported_async_backend::<(&mut T, &mut crate::StoreMut)>(),
+        }
+    }
+
+    /// Borrows a new [`BackendFunctionEnvMut`] from this
+    /// [`BackendAsyncFunctionEnvHandleMut`].
+    pub fn as_function_env_mut(&mut self) -> BackendFunctionEnvMut<'_, T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => BackendFunctionEnvMut::Sys(f.as_function_env_mut()),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for BackendAsyncFunctionEnvHandleMut<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => AsStoreRef::as_store_ref(f),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreMut for BackendAsyncFunctionEnvHandleMut<T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => AsStoreMut::as_store_mut(f),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => AsStoreMut::objects_mut(f),
+            #[cfg(any(
+                feature = "wamr",
+                feature = "wasmi",
+                feature = "v8",
+                feature = "js",
+                feature = "jsc"
+            ))]
+            _ => unsupported_async_backend(),
+        }
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+fn unsupported_async_backend<T>() -> T {
+    panic!("async functions are only supported with the `sys` backend");
+}
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..41b49f942b
--- /dev/null
+++ b/lib/api/src/entities/function/env/mod.rs
@@ -0,0 +1,220 @@
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
+use crate::{AsStoreMut, AsStoreRef, StoreMut, StoreRef, macros::backend::match_rt};
+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()
+    }
+
+    /// Creates an [`AsStoreAsync`] from this [`FunctionEnvMut`] if the current
+    /// context is async.
+    #[cfg(feature = "experimental-async")]
+    pub fn as_store_async(&self) -> Option<impl AsStoreAsync + 'static> {
+        self.0.as_store_async()
+    }
+}
+
+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)
+    }
+}
+
+/// A shared handle to a [`FunctionEnv`], suitable for use
+/// in async imports.
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvMut<T>(pub(crate) BackendAsyncFunctionEnvMut<T>);
+
+/// A read-only handle to the [`FunctionEnv`] in an [`AsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvHandle<T>(pub(crate) BackendAsyncFunctionEnvHandle<T>);
+
+/// A mutable handle to the [`FunctionEnv`] in an [`AsyncFunctionEnvMut`].
+#[cfg(feature = "experimental-async")]
+pub struct AsyncFunctionEnvHandleMut<T>(pub(crate) BackendAsyncFunctionEnvHandleMut<T>);
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvMut<T> {
+    /// Waits for a store lock and returns a read-only handle to the
+    /// function environment.
+    pub async fn read(&self) -> AsyncFunctionEnvHandle<T> {
+        AsyncFunctionEnvHandle(self.0.read().await)
+    }
+
+    /// Waits for a store lock and returns a mutable handle to the
+    /// function environment.
+    pub async fn write(&self) -> AsyncFunctionEnvHandleMut<T> {
+        AsyncFunctionEnvHandleMut(self.0.write().await)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        FunctionEnv(self.0.as_ref())
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> Self {
+        Self(self.0.as_mut())
+    }
+
+    /// Creates an [`AsStoreAsync`] from this [`AsyncFunctionEnvMut`].
+    pub fn as_store_async(&self) -> impl AsStoreAsync + 'static {
+        self.0.as_store_async()
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvHandle<T> {
+    /// Returns a reference to the host state in this function environment.
+    pub fn data(&self) -> &T {
+        self.0.data()
+    }
+
+    /// Returns both the host state and the attached StoreRef
+    pub fn data_and_store(&self) -> (&T, &impl AsStoreRef) {
+        self.0.data_and_store()
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for AsyncFunctionEnvHandle<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        AsStoreRef::as_store_ref(&self.0)
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsyncFunctionEnvHandleMut<T> {
+    /// Returns a mutable reference to the host state in this function environment.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.0.data_mut()
+    }
+
+    /// Returns both the host state and the attached StoreMut
+    pub fn data_and_store_mut(&mut self) -> (&mut T, &mut impl AsStoreMut) {
+        self.0.data_and_store_mut()
+    }
+
+    /// Borrows a new [`FunctionEnvMut`] from this
+    /// [`AsyncFunctionEnvHandleMut`].
+    pub fn as_function_env_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut(self.0.as_function_env_mut())
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreRef for AsyncFunctionEnvHandleMut<T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        AsStoreRef::as_store_ref(&self.0)
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl<T: 'static> AsStoreMut for AsyncFunctionEnvHandleMut<T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        AsStoreMut::as_store_mut(&mut self.0)
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        AsStoreMut::objects_mut(&mut self.0)
+    }
+}
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..5caa5b3342
--- /dev/null
+++ b/lib/api/src/entities/function/host/imp.rs
@@ -0,0 +1,175 @@
+use crate::{
+    AsStoreMut, AsStoreRef, BackendFunctionEnv, BackendFunctionEnvMut, FunctionEnvMut,
+    FunctionType, HostFunction, RuntimeError, StoreInner, StoreMut, StoreRef, Value, WithEnv,
+    WithoutEnv,
+    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
+};
+
+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..b3dcb0023f
--- /dev/null
+++ b/lib/api/src/entities/function/host/mod.rs
@@ -0,0 +1,59 @@
+mod imp;
+
+use crate::{
+    BackendKind, WasmTypeList,
+    vm::{VMFunctionCallback, VMTrampoline},
+};
+
+/// 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..54bbf742dc
--- /dev/null
+++ b/lib/api/src/entities/function/inner.rs
@@ -0,0 +1,801 @@
+use std::pin::Pin;
+
+use wasmer_types::{FunctionType, RawValue};
+
+#[cfg(feature = "experimental-async")]
+use crate::{AsStoreAsync, AsyncFunctionEnvMut, entities::function::async_host::AsyncHostFunction};
+use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, FunctionEnv, FunctionEnvMut,
+    HostFunction, StoreMut, StoreRef, TypedFunction, Value, WasmTypeList, WithEnv, WithoutEnv,
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternFunction, VMFuncRef},
+};
+
+/// 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,
+                ),
+            ),
+        }
+    }
+
+    /// Creates a new async host `Function` (dynamic) with the provided
+    /// signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed_async`] for less runtime overhead.
+    ///
+    /// The provided closure returns a future that resolves to the function results.
+    /// When invoked synchronously
+    /// (via [`Function::call`](crate::Function::call)) the future will run to
+    /// completion immediately, provided it doesn't suspend. When invoked through
+    /// [`Function::call_async`](crate::Function::call_async), the future may suspend
+    /// and resume as needed.
+    #[inline]
+    #[cfg(feature = "experimental-async")]
+    pub fn new_async<FT, F, Fut>(store: &mut impl AsStoreMut, ty: FT, func: F) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(&[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_async(store, ty, func),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsupported_async_backend("wamr"),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsupported_async_backend("wasmi"),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsupported_async_backend("v8"),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsupported_async_backend("js"),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsupported_async_backend("jsc"),
+        }
+    }
+
+    /// Creates a new async host `Function` (dynamic) with the provided
+    /// signature and environment.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed_with_env_async`] for less runtime overhead.
+    ///
+    /// Takes an [`AsyncFunctionEnvMut`] that is passed into func. If
+    /// that is not required, [`Self::new_async`] might be an option as well.
+    #[inline]
+    #[cfg(feature = "experimental-async")]
+    pub fn new_with_env_async<FT, F, Fut, T: 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(AsyncFunctionEnvMut<T>, &[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_with_env_async(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsupported_async_backend("wamr"),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsupported_async_backend("wasmi"),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsupported_async_backend("v8"),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsupported_async_backend("js"),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsupported_async_backend("jsc"),
+        }
+    }
+
+    /// Creates a new async host `Function` from a native typed function.
+    ///
+    /// The future can return either the raw result tuple or any type that implements
+    /// [`IntoResult`](crate::IntoResult) for the result tuple (e.g. `Result<Rets, E>`).
+    #[inline]
+    #[cfg(feature = "experimental-async")]
+    pub fn new_typed_async<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: AsyncHostFunction<(), Args, Rets, WithoutEnv> + 'static,
+        Args: WasmTypeList + 'static,
+        Rets: WasmTypeList + 'static,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_typed_async(store, func),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsupported_async_backend("wamr"),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsupported_async_backend("wasmi"),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsupported_async_backend("v8"),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsupported_async_backend("js"),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsupported_async_backend("jsc"),
+        }
+    }
+
+    /// Creates a new async host `Function` with an environment from a typed function.
+    #[inline]
+    #[cfg(feature = "experimental-async")]
+    pub fn new_typed_with_env_async<T: 'static, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: AsyncHostFunction<T, Args, Rets, WithEnv> + 'static,
+        Args: WasmTypeList + 'static,
+        Rets: WasmTypeList + 'static,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_typed_with_env_async(
+                    store, env, func,
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsupported_async_backend("wamr"),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsupported_async_backend("wasmi"),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsupported_async_backend("v8"),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsupported_async_backend("js"),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsupported_async_backend("jsc"),
+        }
+    }
+
+    /// 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)
+        })
+    }
+
+    #[cfg(feature = "experimental-async")]
+    #[allow(clippy::type_complexity)]
+    pub fn call_async(
+        &self,
+        store: &impl AsStoreAsync,
+        params: Vec<Value>,
+    ) -> Pin<Box<dyn Future<Output = Result<Box<[Value]>, RuntimeError>> + 'static>> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => f.call_async(store, params),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(_) => unsupported_async_future(),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(_) => unsupported_async_future(),
+            #[cfg(feature = "v8")]
+            Self::V8(_) => unsupported_async_future(),
+            #[cfg(feature = "js")]
+            Self::Js(_) => unsupported_async_future(),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(_) => unsupported_async_future(),
+        }
+    }
+
+    #[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(unsafe {
+                crate::backend::sys::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_sys(),
+                )
+            }),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(unsafe {
+                crate::backend::wamr::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_wamr(),
+                )
+            }),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(unsafe {
+                crate::backend::wasmi::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_wasmi(),
+                )
+            }),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(unsafe {
+                crate::backend::v8::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_v8(),
+                )
+            }),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(unsafe {
+                crate::backend::js::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_js(),
+                )
+            }),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(unsafe {
+                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()
+        })
+    }
+}
+
+#[cold]
+fn unsupported_async_backend(backend: &str) -> ! {
+    panic!(
+        "async host functions are only supported with the `sys` backend (attempted on {backend})"
+    )
+}
+
+#[allow(clippy::type_complexity)]
+pub(super) fn unsupported_async_future<'a>()
+-> Pin<Box<dyn Future<Output = Result<Box<[Value]>, RuntimeError>> + 'a>> {
+    Box::pin(async {
+        Err(RuntimeError::new(
+            "async calls are only supported with the `sys` backend",
+        ))
+    })
+}
+
+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 70%
rename from lib/api/src/externals/function.rs
rename to lib/api/src/entities/function/mod.rs
index 70d18c3ca4..32668df27a 100644
--- a/lib/api/src/externals/function.rs
+++ b/lib/api/src/entities/function/mod.rs
@@ -1,77 +1,39 @@
-#[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;
-
-/// 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;
-
-    /// Get the pointer to the function call trampoline.
-    fn call_trampoline_address() -> VMTrampoline {
-        // This is not implemented in JS
-        unimplemented!();
-    }
-}
+pub(crate) mod inner;
+pub use inner::*;
 
-/// 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 {}
+pub(crate) mod host;
+pub use host::*;
 
-/// An empty struct to help Rust typing to determine
-/// when a `HostFunction` does have an environment.
-pub struct WithEnv;
+pub(crate) mod env;
+pub use env::*;
 
-impl HostFunctionKind for WithEnv {}
+#[cfg(feature = "experimental-async")]
+pub(crate) mod async_host;
+#[cfg(feature = "experimental-async")]
+pub use async_host::{AsyncFunctionEnv, AsyncHostFunction};
 
-/// An empty struct to help Rust typing to determine
-/// when a `HostFunction` does not have an environment.
-pub struct WithoutEnv;
+use std::{future::Future, pin::Pin};
 
-impl HostFunctionKind for WithoutEnv {}
+use wasmer_types::{FunctionType, RawValue};
 
-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 {}
-}
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
+use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, TypedFunction,
+    Value, WasmTypeList,
+    error::RuntimeError,
+    vm::{VMExtern, VMExternFunction, VMFuncRef},
+};
 
 /// 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 +45,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 +59,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 +112,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 +122,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 +153,79 @@ 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))
+    }
+
+    /// Creates a new async host `Function` (dynamic) with the provided
+    /// signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed_async`] for less runtime overhead.
+    ///
+    /// The provided closure returns a future that resolves to the function results.
+    /// When invoked synchronously (via [`Function::call`]) the future will run to
+    /// completion immediately, provided it doesn't suspend. When invoked through
+    /// [`Function::call_async`], the future may suspend and resume as needed.
+    #[cfg(feature = "experimental-async")]
+    pub fn new_async<FT, F, Fut>(store: &mut impl AsStoreMut, ty: FT, func: F) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(&[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        Self(BackendFunction::new_async(store, ty, func))
+    }
+
+    /// Creates a new async host `Function` (dynamic) with the provided
+    /// signature and environment.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed_with_env_async`] for less runtime overhead.
+    ///
+    /// Takes an [`AsyncFunctionEnvMut`] that is passed into func. If
+    /// that is not required, [`Self::new_async`] might be an option as well.
+    #[cfg(feature = "experimental-async")]
+    pub fn new_with_env_async<FT, F, Fut, T: 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(AsyncFunctionEnvMut<T>, &[Value]) -> Fut + 'static,
+        Fut: Future<Output = Result<Vec<Value>, RuntimeError>> + 'static,
+    {
+        Self(BackendFunction::new_with_env_async(store, env, ty, func))
+    }
+
+    /// Creates a new async host `Function` from a native typed function.
+    ///
+    /// The future can return either the raw result tuple or any type that implements
+    /// [`IntoResult`](crate::IntoResult) for the result tuple (e.g. `Result<Rets, E>`).
+    #[cfg(feature = "experimental-async")]
+    pub fn new_typed_async<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        Rets: WasmTypeList + 'static,
+        Args: WasmTypeList + 'static,
+        F: AsyncHostFunction<(), Args, Rets, WithoutEnv> + 'static,
+    {
+        Self(BackendFunction::new_typed_async(store, func))
+    }
+
+    /// Creates a new async host `Function` with an environment from a typed function.
+    #[cfg(feature = "experimental-async")]
+    pub fn new_typed_with_env_async<T: 'static, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        Rets: WasmTypeList + 'static,
+        Args: WasmTypeList + 'static,
+        F: AsyncHostFunction<T, Args, Rets, WithEnv> + 'static,
+    {
+        Self(BackendFunction::new_typed_with_env_async(store, env, func))
     }
 
     /// Returns the [`FunctionType`] of the `Function`.
@@ -263,7 +292,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
@@ -302,6 +331,22 @@ impl Function {
         self.0.call(store, params)
     }
 
+    /// Calls the function asynchronously.
+    ///
+    /// The returned future drives execution of the WebAssembly function on a
+    /// coroutine stack. Host functions created with [`Function::new_async`] may
+    /// suspend execution by awaiting futures, and their completion will resume
+    /// the Wasm instance according to the JSPI proposal.
+    #[must_use = "This function spawns a future that must be awaited to produce results"]
+    #[cfg(feature = "experimental-async")]
+    pub fn call_async(
+        &self,
+        store: &impl AsStoreAsync,
+        params: Vec<Value>,
+    ) -> impl Future<Output = Result<Box<[Value]>, RuntimeError>> + 'static {
+        self.0.call_async(store, params)
+    }
+
     #[doc(hidden)]
     #[allow(missing_docs)]
     pub fn call_raw(
@@ -317,7 +362,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))
+        unsafe { Self(BackendFunction::from_vm_funcref(store, funcref)) }
     }
 
     /// Transform this WebAssembly function into a typed function.
@@ -409,41 +454,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 +471,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..bb867eeba4
--- /dev/null
+++ b/lib/api/src/entities/global/inner.rs
@@ -0,0 +1,228 @@
+use crate::{
+    ExportError, Exportable, Extern,
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
+    value::Value,
+    vm::{VMExtern, VMExternGlobal},
+};
+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..93b3fc5025 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::{
+    ExportError, Exportable, Extern,
+    error::RuntimeError,
+    store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
+    value::Value,
+    vm::{VMExtern, VMExternGlobal},
+};
+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 97%
rename from lib/api/src/imports.rs
rename to lib/api/src/entities/imports.rs
index 344bc24e28..2efb2f2606 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::{Exports, Extern, Module, error::LinkError};
 use std::collections::HashMap;
 use std::fmt;
 use wasmer_types::ImportError;
@@ -130,11 +130,7 @@ impl Imports {
             .filter(|((ns, _), _)| ns == name)
             .map(|((_, name), e)| (name.clone(), e.clone()))
             .collect();
-        if ret.is_empty() {
-            None
-        } else {
-            Some(ret)
-        }
+        if ret.is_empty() { None } else { Some(ret) }
     }
 
     /// Resolve and return a vector of imports in the order they are defined in the `module`'s source code.
@@ -166,12 +162,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 +222,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) ...)"),
                 }
             }
         }
@@ -305,10 +302,10 @@ macro_rules! import_namespace {
 
 #[cfg(test)]
 mod test {
-    use crate::store::Store;
-    use crate::value::Value;
     use crate::Extern;
     use crate::Global;
+    use crate::store::Store;
+    use crate::value::Value;
     use wasmer_types::Type;
 
     #[test]
@@ -462,6 +459,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..761e160e9c
--- /dev/null
+++ b/lib/api/src/entities/instance.rs
@@ -0,0 +1,182 @@
+use crate::{
+    Extern, error::InstantiationError, exports::Exports, imports::Imports,
+    macros::backend::gen_rt_ty, module::Module, store::AsStoreMut,
+};
+
+/// 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..4cc3c199d2
--- /dev/null
+++ b/lib/api/src/entities/memory/buffer/inner.rs
@@ -0,0 +1,92 @@
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use crate::{
+    MemoryAccessError,
+    macros::backend::{gen_rt_ty, match_rt},
+};
+
+/// 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..74dd52c960
--- /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::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternMemory, VMMemory},
+};
+
+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..e869b2fb70
--- /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::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
+    vm::{VMExtern, VMExternMemory, VMMemory},
+};
+
+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..9d7bac06c2
--- /dev/null
+++ b/lib/api/src/entities/memory/shared.rs
@@ -0,0 +1,78 @@
+use wasmer_types::MemoryError;
+
+use crate::{
+    Memory,
+    error::AtomicsError,
+    location::{MemoryLocation, SharedMemoryOps},
+};
+
+/// 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..c0ff910388
--- /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::{
+    AsStoreRef, Memory, MemoryAccessError,
+    buffer::{BackendMemoryBuffer, MemoryBuffer},
+    macros::backend::{gen_rt_ty, match_rt},
+};
+
+/// 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 {
+            unsafe { 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 {
+            unsafe { 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..8f16105dc5
--- /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::{AsStoreRef, Memory, MemoryAccessError, buffer::MemoryBuffer};
+
+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] {
+        unsafe { 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] {
+        unsafe { 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..5308eb18f0
--- /dev/null
+++ b/lib/api/src/entities/module/inner.rs
@@ -0,0 +1,769 @@
+//! 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::{
+    CompilationProgressCallback, CompileError, DeserializeError, ExportType, ExportsIterator,
+    ImportType, ImportsIterator, ModuleInfo, SerializeError,
+};
+
+use crate::{
+    AsEngineRef,
+    macros::backend::{gen_rt_ty, match_rt},
+    utils::IntoBytes,
+};
+
+/// 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())
+    }
+
+    #[inline]
+    pub fn new_with_progress(
+        engine: &impl AsEngineRef,
+        bytes: impl AsRef<[u8]>,
+        callback: CompilationProgressCallback,
+    ) -> 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}",
+            )))
+        })?;
+
+        #[cfg(feature = "sys")]
+        return crate::backend::sys::entities::module::Module::from_binary_with_progress(
+            engine,
+            bytes.as_ref(),
+            callback,
+        )
+        .map(Self::Sys);
+        #[cfg(not(feature = "sys"))]
+        return 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(_) => {
+                let module = unsafe {
+                    crate::backend::sys::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Sys(module))
+            }
+
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                let module = unsafe {
+                    crate::backend::wamr::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Wamr(module))
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                let module = unsafe {
+                    crate::backend::wasmi::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Wasmi(module))
+            }
+
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                let module = unsafe {
+                    crate::backend::v8::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::V8(module))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                let module = unsafe {
+                    crate::backend::js::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Js(module))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
+        }
+    }
+
+    /// 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(_) => {
+                let module = unsafe {
+                    crate::backend::sys::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Sys(module))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                let module = unsafe {
+                    crate::backend::wamr::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Wamr(module))
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                let module = unsafe {
+                    crate::backend::wasmi::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Wasmi(module))
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                let module = unsafe {
+                    crate::backend::v8::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::V8(module))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                let module = unsafe {
+                    crate::backend::js::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Js(module))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
+        }
+    }
+
+    /// 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(_) => {
+                let module = unsafe {
+                    crate::backend::sys::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Sys(module))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                let module = unsafe {
+                    crate::backend::wamr::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Wamr(module))
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                let module = unsafe {
+                    crate::backend::wasmi::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Wasmi(module))
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                let module = unsafe {
+                    crate::backend::v8::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::V8(module))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                let module = unsafe {
+                    crate::backend::js::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Js(module))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Jsc(module))
+            }
+        }
+    }
+
+    /// 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::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// 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(_) => {
+                let module = unsafe {
+                    crate::backend::sys::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Sys(module))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                let module = unsafe {
+                    crate::backend::wamr::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Wamr(module))
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                let module = unsafe {
+                    crate::backend::wasmi::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Wasmi(module))
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                let module = unsafe {
+                    crate::backend::v8::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::V8(module))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                let module = unsafe {
+                    crate::backend::js::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Js(module))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
+        }
+    }
+
+    /// 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::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// 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(_) => {
+                let module = unsafe {
+                    crate::backend::sys::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Sys(module))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                let module = unsafe {
+                    crate::backend::wamr::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Wamr(module))
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                let module = unsafe {
+                    crate::backend::wasmi::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Wasmi(module))
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                let module = unsafe {
+                    crate::backend::v8::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::V8(module))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                let module = unsafe {
+                    crate::backend::js::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Js(module))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
+        }
+    }
+
+    /// 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..0ecf0c33a9 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 std::{fs, path::Path};
 
-use crate::engine::AsEngineRef;
+use bytes::Bytes;
 use thiserror::Error;
 #[cfg(feature = "wat")]
 use wasmer_types::WasmError;
 use wasmer_types::{
-    CompileError, DeserializeError, ExportsIterator, ImportsIterator, ModuleInfo, SerializeError,
+    CompilationProgress, CompilationProgressCallback, CompileError, DeserializeError, ExportType,
+    ExportsIterator, ImportType, ImportsIterator, ModuleInfo, SerializeError, UserAbort,
 };
-use wasmer_types::{ExportType, ImportType};
-
-use crate::into_bytes::IntoBytes;
 
-#[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;
+use crate::{AsEngineRef, macros::backend::match_rt, utils::IntoBytes};
 
-/// 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,
-        )?))
+        unsafe { 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,
-        )?))
+        unsafe { 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)?))
+        unsafe { BackendModule::deserialize_unchecked(engine, bytes) }.map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -298,8 +276,8 @@ impl Module {
     ///
     /// ```ignore
     /// # use wasmer::*;
-    /// # let mut store = Store::default();
     /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
     /// let module = Module::deserialize_from_file(&store, path)?;
     /// # Ok(())
     /// # }
@@ -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,
-        )?))
+        unsafe { BackendModule::deserialize_from_file(engine, path) }.map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -330,8 +306,8 @@ impl Module {
     ///
     /// ```ignore
     /// # use wasmer::*;
-    /// # let mut store = Store::default();
     /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
     /// let module = Module::deserialize_from_file_unchecked(&store, path)?;
     /// # Ok(())
     /// # }
@@ -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,
-        )?))
+        unsafe { 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/async_.rs b/lib/api/src/entities/store/async_.rs
new file mode 100644
index 0000000000..fa557c174f
--- /dev/null
+++ b/lib/api/src/entities/store/async_.rs
@@ -0,0 +1,160 @@
+use std::{fmt::Debug, marker::PhantomData};
+
+use crate::{
+    AsStoreMut, AsStoreRef, LocalRwLock, LocalRwLockReadGuard, LocalRwLockWriteGuard, Store,
+    StoreContext, StoreInner, StoreMut, StorePtrWrapper, StoreRef,
+};
+
+use wasmer_types::StoreId;
+
+/// A store that can be used to invoke
+/// [`Function::call_async`](crate::Function::call_async).
+pub struct StoreAsync {
+    pub(crate) id: StoreId,
+    // We use a box inside the RW lock because the StoreInner shouldn't be moved
+    pub(crate) inner: LocalRwLock<Box<StoreInner>>,
+}
+
+impl StoreAsync {
+    pub(crate) fn from_context(id: StoreId) -> Option<Self> {
+        // Safety: we don't keep the guard around, it's just used to
+        // build a safe lock handle.
+        match unsafe { StoreContext::try_get_current_async(id) } {
+            crate::GetStoreAsyncGuardResult::Ok(guard) => Some(Self {
+                id,
+                inner: crate::LocalRwLockWriteGuard::lock_handle(unsafe {
+                    guard.guard.as_ref().unwrap()
+                }),
+            }),
+            _ => None,
+        }
+    }
+
+    /// Transform this [`StoreAsync`] back into a [`Store`]
+    /// if this is the only clone of it and is unlocked.
+    pub fn into_store(self) -> Result<Store, Self> {
+        match self.inner.consume() {
+            Ok(unwrapped) => Ok(Store { inner: unwrapped }),
+            Err(lock) => Err(Self {
+                id: self.id,
+                inner: lock,
+            }),
+        }
+    }
+
+    /// Acquire a read lock on the store. Panics if the store is
+    /// locked for writing.
+    pub fn read(&self) -> StoreAsyncReadLock {
+        if !StoreContext::is_empty() {
+            panic!("This method cannot be called from inside imported functions");
+        }
+
+        let store_ref = self
+            .inner
+            .try_read()
+            .expect("StoreAsync is locked for write");
+        StoreAsyncReadLock { inner: store_ref }
+    }
+
+    /// Acquire a write lock on the store. Panics if the store is
+    /// locked.
+    pub fn write(self) -> StoreAsyncWriteLock {
+        if !StoreContext::is_empty() {
+            panic!("This method cannot be called from inside imported functions");
+        }
+
+        let store_guard = self.inner.try_write().expect("StoreAsync is locked");
+        StoreAsyncWriteLock { inner: store_guard }
+    }
+}
+
+impl Debug for StoreAsync {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StoreAsync").field("id", &self.id).finish()
+    }
+}
+
+/// A trait for types that can be used with
+/// [`Function::call_async`](crate::Function::call_async).
+pub trait AsStoreAsync {
+    /// Returns a reference to the inner store.
+    fn store_ref(&self) -> &StoreAsync;
+
+    /// Returns a copy of the store.
+    fn store(&self) -> StoreAsync {
+        let store = self.store_ref();
+        StoreAsync {
+            id: store.id,
+            inner: store.inner.clone(),
+        }
+    }
+
+    /// Returns the store id.
+    fn store_id(&self) -> StoreId {
+        self.store().id
+    }
+
+    /// Acquires a read lock on the store.
+    fn read_lock(&self) -> impl Future<Output = StoreAsyncReadLock> {
+        StoreAsyncReadLock::acquire(self.store_ref())
+    }
+
+    /// Acquires a write lock on the store.
+    fn write_lock(&self) -> impl Future<Output = StoreAsyncWriteLock> {
+        StoreAsyncWriteLock::acquire(self.store_ref())
+    }
+}
+
+impl AsStoreAsync for StoreAsync {
+    fn store_ref(&self) -> &StoreAsync {
+        self
+    }
+}
+
+/// A read lock on an async store.
+pub struct StoreAsyncReadLock {
+    pub(crate) inner: LocalRwLockReadGuard<Box<StoreInner>>,
+}
+
+impl StoreAsyncReadLock {
+    pub(crate) async fn acquire(store: &StoreAsync) -> Self {
+        let store_ref = store.inner.read().await;
+        Self { inner: store_ref }
+    }
+}
+
+impl AsStoreRef for StoreAsyncReadLock {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: &self.inner }
+    }
+}
+
+/// A write lock on an async store.
+pub struct StoreAsyncWriteLock {
+    pub(crate) inner: LocalRwLockWriteGuard<Box<StoreInner>>,
+}
+
+impl StoreAsyncWriteLock {
+    pub(crate) async fn acquire(store: &StoreAsync) -> Self {
+        let store_guard = store.inner.write().await;
+        Self { inner: store_guard }
+    }
+}
+
+impl AsStoreRef for StoreAsyncWriteLock {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: &self.inner }
+    }
+}
+
+impl AsStoreMut for StoreAsyncWriteLock {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: &mut self.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut super::StoreObjects {
+        &mut self.inner.objects
+    }
+}
diff --git a/lib/api/src/entities/store/context.rs b/lib/api/src/entities/store/context.rs
new file mode 100644
index 0000000000..3c4285bf3b
--- /dev/null
+++ b/lib/api/src/entities/store/context.rs
@@ -0,0 +1,459 @@
+//! Thread-local storage for storing the current store context,
+//! i.e. the currently active [`Store`](crate::Store)(s). When
+//! a function is called, a pointer to the [`StoreInner`] in placed
+//! inside the store context so it can be retrieved when needed.
+//! This lets code that needs access to the store get it with
+//! just the store ID.
+//!
+//! The currently active store context can be a sync or async
+//! context.
+//!
+//! For sync contexts, we just store a raw pointer
+//! to the `StoreInner`, which is owned by the embedder's stack.
+//!
+//! For async contexts, we store a write guard taken from the
+//! [`StoreAsync`](crate::StoreAsync); This achieves two goals:
+//!   * Makes the [`StoreAsync`](crate::StoreAsync) available
+//!     to whoever needs it, including when code needs to spawn
+//!     new coroutines
+//!   * Makes sure a write lock is held on the store as long as
+//!     the context is active, preventing other tasks from
+//!     accessing the store concurrently.
+//!
+//! We maintain a stack because it is technically possible to
+//! have nested `Function::call` invocations that use different
+//! stores, such as:
+//!     call(store1, func1) -> wasm code -> imported func ->
+//!     call(store2, func2)
+//!
+//! Note that this stack is maintained by both function
+//! calls and the async_runtime to reflect the exact WASM
+//! functions running on a given thread at any moment in
+//! time. If a function suspends, its store context is
+//! cleared and later reinstalled when it resumes. This lets
+//! us use thread-local storage for the context without
+//! requiring that async tasks are tied to specific threads.
+//!
+//! When something needs the "currently active" store context,
+//! they will only look at the top entry in the stack. It is
+//! always an error for code to try to access a store that's
+//! "paused", i.e. not the top entry. This should be impossible
+//! due to how the function call code is structured, but we
+//! guard against it anyway.
+
+use std::{
+    borrow::BorrowMut,
+    cell::{RefCell, UnsafeCell},
+    mem::MaybeUninit,
+};
+
+#[cfg(feature = "experimental-async")]
+use crate::LocalRwLockWriteGuard;
+
+use super::{AsStoreMut, AsStoreRef, StoreInner, StoreMut, StoreRef};
+
+use wasmer_types::StoreId;
+
+enum StoreContextEntry {
+    Sync(*mut StoreInner),
+
+    #[cfg(feature = "experimental-async")]
+    Async(LocalRwLockWriteGuard<Box<StoreInner>>),
+}
+
+impl StoreContextEntry {
+    fn as_ptr(&self) -> *mut StoreInner {
+        match self {
+            Self::Sync(ptr) => *ptr,
+            #[cfg(feature = "experimental-async")]
+            Self::Async(guard) => &***guard as *const _ as *mut _,
+        }
+    }
+}
+
+pub(crate) struct StoreContext {
+    id: StoreId,
+
+    // StoreContexts can be used recursively when Function::call
+    // is used in an imported function. In the scenario, we're
+    // essentially passing a mutable borrow of the store into
+    // Function::call. However, entering the WASM code loses the
+    // reference, and it needs to be re-acquired from the
+    // StoreContext. This is why we use an UnsafeCell to allow
+    // multiple mutable references to the StoreMut; we do however
+    // keep track of how many borrows there are so we don't drop
+    // it prematurely.
+    borrow_count: u32,
+    entry: UnsafeCell<StoreContextEntry>,
+}
+
+pub(crate) struct StorePtrWrapper {
+    store_ptr: *mut StoreInner,
+}
+
+#[cfg(feature = "experimental-async")]
+pub(crate) struct StoreAsyncGuardWrapper {
+    pub(crate) guard: *mut LocalRwLockWriteGuard<Box<StoreInner>>,
+}
+
+pub(crate) struct StorePtrPauseGuard {
+    store_id: StoreId,
+    ptr: *mut StoreInner,
+    ref_count_decremented: bool,
+}
+
+#[cfg(feature = "experimental-async")]
+pub(crate) enum GetStoreAsyncGuardResult {
+    Ok(StoreAsyncGuardWrapper),
+    NotAsync(StorePtrWrapper),
+    NotInstalled,
+}
+
+pub(crate) struct ForcedStoreInstallGuard {
+    store_id: StoreId,
+}
+
+pub(crate) enum StoreInstallGuard {
+    Installed(StoreId),
+    NotInstalled,
+}
+
+thread_local! {
+    static STORE_CONTEXT_STACK: RefCell<Vec<StoreContext>> = const { RefCell::new(Vec::new()) };
+}
+
+impl StoreContext {
+    fn is_active(id: StoreId) -> bool {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let stack = cell.borrow();
+            stack.last().is_some_and(|ctx| ctx.id == id)
+        })
+    }
+
+    fn is_suspended(id: StoreId) -> bool {
+        !Self::is_active(id)
+            && STORE_CONTEXT_STACK.with(|cell| {
+                let stack = cell.borrow();
+                stack.iter().rev().skip(1).any(|ctx| ctx.id == id)
+            })
+    }
+
+    fn install(id: StoreId, entry: StoreContextEntry) {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            stack.push(Self {
+                id,
+                borrow_count: 0,
+                entry: UnsafeCell::new(entry),
+            });
+        })
+    }
+
+    /// Returns true if there are no active store context entries.
+    pub(crate) fn is_empty() -> bool {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let stack = cell.borrow();
+            stack.is_empty()
+        })
+    }
+
+    /// The write guard ensures this is the only reference to the store,
+    /// so installation can never fail.
+    #[cfg(feature = "experimental-async")]
+    pub(crate) fn install_async(
+        guard: LocalRwLockWriteGuard<Box<StoreInner>>,
+    ) -> ForcedStoreInstallGuard {
+        let store_id = guard.objects.id();
+        Self::install(store_id, StoreContextEntry::Async(guard));
+        ForcedStoreInstallGuard { store_id }
+    }
+
+    /// Install the store context as sync if it is not already installed.
+    ///
+    /// # Safety
+    /// The pointer must be dereferenceable and remain valid until the
+    /// store context is uninstalled.
+    pub(crate) unsafe fn ensure_installed(store_ptr: *mut StoreInner) -> StoreInstallGuard {
+        let store_id = unsafe { store_ptr.as_ref().unwrap().objects.id() };
+        if Self::is_active(store_id) {
+            let current_ptr = STORE_CONTEXT_STACK.with(|cell| {
+                let stack = cell.borrow();
+                unsafe { stack.last().unwrap().entry.get().as_ref().unwrap().as_ptr() }
+            });
+            assert_eq!(store_ptr, current_ptr, "Store context pointer mismatch");
+            StoreInstallGuard::NotInstalled
+        } else {
+            Self::install(store_id, StoreContextEntry::Sync(store_ptr));
+            StoreInstallGuard::Installed(store_id)
+        }
+    }
+
+    /// "Pause" one borrow of the store context.
+    ///
+    /// # Safety
+    /// Code must ensure it does not use the StorePtrWrapper or
+    /// StoreAsyncGuardWrapper that it owns, or any StoreRef/StoreMut
+    /// derived from them, while the store context is paused.
+    ///
+    /// The safe, correct use-case for this method is to
+    /// pause the store context while executing WASM code, which
+    /// cannot use the store context directly. This allows an async
+    /// context to uninstall the store context when suspending if it's
+    /// called from a sync imported function. The imported function
+    /// will have borrowed the store context in its trampoline, which
+    /// will prevent the async context from uninstalling the store.
+    /// However, since the imported function passes a mutable borrow
+    /// of its store into `Function::call`, it will expect the store
+    /// to change before the call returns.
+    pub(crate) unsafe fn pause(id: StoreId) -> StorePtrPauseGuard {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, id, "Mismatched store context access");
+            let ref_count_decremented = if top.borrow_count > 0 {
+                top.borrow_count -= 1;
+                true
+            } else {
+                false
+            };
+            StorePtrPauseGuard {
+                store_id: id,
+                ptr: unsafe { top.entry.get().as_ref().unwrap().as_ptr() },
+                ref_count_decremented,
+            }
+        })
+    }
+
+    /// Safety: This method lets you borrow multiple mutable references
+    /// to the currently active store context. The caller must ensure that:
+    ///   * there is only one mutable reference alive, or
+    ///   * all but one mutable reference are inaccessible and passed
+    ///     into a function that lost the reference (e.g. into WASM code)
+    ///
+    /// The intended, valid use-case for this method is from within
+    /// imported function trampolines.
+    pub(crate) unsafe fn get_current(id: StoreId) -> StorePtrWrapper {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, id, "Mismatched store context access");
+            top.borrow_count += 1;
+            StorePtrWrapper {
+                store_ptr: unsafe { top.entry.get().as_mut().unwrap().as_ptr() },
+            }
+        })
+    }
+
+    /// Safety: In addition to the safety requirements of [`Self::get_current`],
+    /// the pointer returned from this function will become invalid if
+    /// the store context is changed in any way (via installing or uninstalling
+    /// a store context). The caller must ensure that the store context
+    /// remains unchanged as long as the pointer is being accessed.
+    pub(crate) unsafe fn get_current_transient(id: StoreId) -> *mut StoreInner {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, id, "Mismatched store context access");
+            unsafe { top.entry.get().as_mut().unwrap().as_ptr() }
+        })
+    }
+
+    /// Safety: See [`Self::get_current`].
+    pub(crate) unsafe fn try_get_current(id: StoreId) -> Option<StorePtrWrapper> {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack.last_mut()?;
+            if top.id != id {
+                return None;
+            }
+            top.borrow_count += 1;
+            Some(StorePtrWrapper {
+                store_ptr: unsafe { top.entry.get().as_mut().unwrap().as_ptr() },
+            })
+        })
+    }
+
+    /// Safety: See [`Self::get_current`].
+    #[cfg(feature = "experimental-async")]
+    pub(crate) unsafe fn try_get_current_async(id: StoreId) -> GetStoreAsyncGuardResult {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let Some(top) = stack.last_mut() else {
+                return GetStoreAsyncGuardResult::NotInstalled;
+            };
+            if top.id != id {
+                return GetStoreAsyncGuardResult::NotInstalled;
+            }
+            top.borrow_count += 1;
+            match unsafe { top.entry.get().as_mut().unwrap() } {
+                StoreContextEntry::Async(guard) => {
+                    GetStoreAsyncGuardResult::Ok(StoreAsyncGuardWrapper {
+                        guard: guard as *mut _,
+                    })
+                }
+                StoreContextEntry::Sync(ptr) => {
+                    GetStoreAsyncGuardResult::NotAsync(StorePtrWrapper { store_ptr: *ptr })
+                }
+            }
+        })
+    }
+}
+
+impl StorePtrWrapper {
+    pub(crate) fn as_ref(&self) -> StoreRef<'_> {
+        // Safety: the store_mut is always initialized unless the StoreMutWrapper
+        // is dropped, at which point it's impossible to call this function
+        unsafe { self.store_ptr.as_ref().unwrap().as_store_ref() }
+    }
+
+    pub(crate) fn as_mut(&mut self) -> StoreMut<'_> {
+        // Safety: the store_mut is always initialized unless the StoreMutWrapper
+        // is dropped, at which point it's impossible to call this function
+        unsafe { self.store_ptr.as_mut().unwrap().as_store_mut() }
+    }
+}
+
+impl Clone for StorePtrWrapper {
+    fn clone(&self) -> Self {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            match unsafe { top.entry.get().as_ref().unwrap() } {
+                StoreContextEntry::Sync(ptr) if *ptr == self.store_ptr => (),
+                _ => panic!("Mismatched store context access"),
+            }
+            top.borrow_count += 1;
+            Self {
+                store_ptr: self.store_ptr,
+            }
+        })
+    }
+}
+
+impl Drop for StorePtrWrapper {
+    fn drop(&mut self) {
+        if std::thread::panicking() {
+            return;
+        }
+        let id = self.as_mut().objects_mut().id();
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, id, "Mismatched store context reinstall");
+            top.borrow_count -= 1;
+        })
+    }
+}
+
+#[cfg(feature = "experimental-async")]
+impl Drop for StoreAsyncGuardWrapper {
+    fn drop(&mut self) {
+        if std::thread::panicking() {
+            return;
+        }
+        let id = unsafe { self.guard.as_ref().unwrap().objects.id() };
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, id, "Mismatched store context reinstall");
+            top.borrow_count -= 1;
+        })
+    }
+}
+
+impl Drop for StoreInstallGuard {
+    fn drop(&mut self) {
+        if let Self::Installed(store_id) = self {
+            STORE_CONTEXT_STACK.with(|cell| {
+                let mut stack = cell.borrow_mut();
+                match (stack.pop(), std::thread::panicking()) {
+                    (Some(top), false) => {
+                        assert_eq!(top.id, *store_id, "Mismatched store context uninstall");
+                        assert_eq!(
+                            top.borrow_count, 0,
+                            "Cannot uninstall store context while it is still borrowed"
+                        );
+                    }
+                    (Some(top), true) => {
+                        // If we're panicking and there's a store ID mismatch, just
+                        // put the store back in the hope that its own install guard
+                        // take care of uninstalling it later.
+                        if top.id != *store_id {
+                            stack.push(top);
+                        }
+                    }
+                    (None, false) => panic!("Store context stack underflow"),
+                    (None, true) => {
+                        // Nothing to do if we're panicking; panics can put the context
+                        // in an invalid state, and we don't to cause another panic here.
+                    }
+                }
+            })
+        }
+    }
+}
+
+impl Drop for ForcedStoreInstallGuard {
+    fn drop(&mut self) {
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            match (stack.pop(), std::thread::panicking()) {
+                (Some(top), false) => {
+                    assert_eq!(top.id, self.store_id, "Mismatched store context uninstall");
+                    assert_eq!(
+                        top.borrow_count, 0,
+                        "Cannot uninstall store context while it is still borrowed"
+                    );
+                }
+                (Some(top), true) => {
+                    // If we're panicking and there's a store ID mismatch, just
+                    // put the store back in the hope that its own install guard
+                    // take care of uninstalling it later.
+                    if top.id != self.store_id {
+                        stack.push(top);
+                    }
+                }
+                (None, false) => panic!("Store context stack underflow"),
+                (None, true) => {
+                    // Nothing to do if we're panicking; panics can put the context
+                    // in an invalid state, and we don't to cause another panic here.
+                }
+            }
+        })
+    }
+}
+
+impl Drop for StorePtrPauseGuard {
+    fn drop(&mut self) {
+        if std::thread::panicking() {
+            return;
+        }
+        STORE_CONTEXT_STACK.with(|cell| {
+            let mut stack = cell.borrow_mut();
+            let top = stack
+                .last_mut()
+                .expect("No store context installed on this thread");
+            assert_eq!(top.id, self.store_id, "Mismatched store context access");
+            assert_eq!(
+                unsafe { top.entry.get().as_ref().unwrap() }.as_ptr(),
+                self.ptr,
+                "Mismatched store context access"
+            );
+            if self.ref_count_decremented {
+                top.borrow_count += 1;
+            }
+        })
+    }
+}
diff --git a/lib/api/src/entities/store/inner.rs b/lib/api/src/entities/store/inner.rs
new file mode 100644
index 0000000000..c977b01acb
--- /dev/null
+++ b/lib/api/src/entities/store/inner.rs
@@ -0,0 +1,81 @@
+use crate::{
+    AsStoreMut, AsStoreRef, StoreRef,
+    entities::{
+        engine::{AsEngineRef, Engine},
+        store::{StoreMut, StoreObjects},
+    },
+    macros::backend::{gen_rt_ty, match_rt},
+};
+
+#[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()
+    }
+}
+
+impl AsStoreRef for StoreInner {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: self }
+    }
+}
+impl AsStoreMut for StoreInner {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut { inner: self }
+    }
+
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.objects
+    }
+}
+
+/// 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/local_rwlock.rs b/lib/api/src/entities/store/local_rwlock.rs
new file mode 100644
index 0000000000..8eb6c53a87
--- /dev/null
+++ b/lib/api/src/entities/store/local_rwlock.rs
@@ -0,0 +1,648 @@
+//! A single-threaded async-aware RwLock implementation.
+//!
+//! This module provides [`LocalRwLock`], which is similar to `async_lock::RwLock`
+//! but optimized for single-threaded async runtimes. It avoids atomic operations
+//! and is `!Send + !Sync`, making it more efficient when thread safety is not needed.
+//!
+//! Like `async_lock::RwLock`, it provides `read_rc()` and `write_rc()` methods
+//! that allow callers to asynchronously wait for the lock to become available,
+//! and return guards with `'static` lifetimes by holding an `Rc` to the lock.
+
+use std::cell::{Cell, RefCell, UnsafeCell};
+use std::future::Future;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll, Waker};
+
+/// The main lock type.
+pub struct LocalRwLock<T> {
+    inner: Rc<LocalRwLockInner<T>>,
+}
+
+struct LocalRwLockInner<T> {
+    value: UnsafeCell<T>,
+    state: Cell<LockState>,
+    read_waiters: RefCell<Vec<Option<Waker>>>,
+    write_waiters: RefCell<Vec<Option<Waker>>>,
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+enum LockState {
+    Unlocked,
+    Reading(usize), // count of readers
+    Writing,
+}
+
+impl<T> LocalRwLock<T> {
+    /// Creates a new `LocalRwLock` with the given value.
+    pub fn new(value: T) -> Self {
+        Self {
+            inner: Rc::new(LocalRwLockInner {
+                value: UnsafeCell::new(value),
+                state: Cell::new(LockState::Unlocked),
+                read_waiters: RefCell::new(Vec::new()),
+                write_waiters: RefCell::new(Vec::new()),
+            }),
+        }
+    }
+
+    /// Acquires a read lock, waiting asynchronously if necessary.
+    ///
+    /// The returned guard holds an `Rc` clone, allowing it to have a `'static` lifetime.
+    pub fn read(&self) -> ReadFuture<T> {
+        ReadFuture {
+            inner: self.inner.clone(),
+            waiter_index: Cell::new(None),
+        }
+    }
+
+    /// Acquires a write lock, waiting asynchronously if necessary.
+    ///
+    /// The returned guard holds an `Rc` clone, allowing it to have a `'static` lifetime.
+    pub fn write(&self) -> WriteFuture<T> {
+        WriteFuture {
+            inner: self.inner.clone(),
+            waiter_index: Cell::new(None),
+        }
+    }
+
+    /// Attempts to acquire a read lock with a `'static` lifetime without waiting.
+    pub fn try_read(&self) -> Option<LocalRwLockReadGuard<T>> {
+        if self.inner.try_read() {
+            Some(LocalRwLockReadGuard {
+                inner: self.inner.clone(),
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Attempts to acquire a write lock with a `'static` lifetime without waiting.
+    pub fn try_write(&self) -> Option<LocalRwLockWriteGuard<T>> {
+        if self.inner.try_write() {
+            Some(LocalRwLockWriteGuard {
+                inner: self.inner.clone(),
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Attempts to consume the lock if there are no active or waiting
+    /// readers or writers, and returns the inner value if successful.
+    pub fn consume(self) -> Result<T, Self> {
+        if self.inner.state.get() == LockState::Unlocked
+            && self.inner.read_waiters.borrow().is_empty()
+            && self.inner.write_waiters.borrow().is_empty()
+        {
+            match Rc::try_unwrap(self.inner) {
+                Ok(inner) => Ok(inner.value.into_inner()),
+                Err(rc) => Err(Self { inner: rc }),
+            }
+        } else {
+            Err(self)
+        }
+    }
+}
+
+impl<T> Clone for LocalRwLock<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> LocalRwLockInner<T> {
+    fn try_read(&self) -> bool {
+        match self.state.get() {
+            LockState::Unlocked => {
+                self.state.set(LockState::Reading(1));
+                true
+            }
+            LockState::Reading(n) => {
+                self.state.set(LockState::Reading(n + 1));
+                true
+            }
+            LockState::Writing => false,
+        }
+    }
+
+    fn try_write(&self) -> bool {
+        match self.state.get() {
+            LockState::Unlocked => {
+                self.state.set(LockState::Writing);
+                true
+            }
+            _ => false,
+        }
+    }
+
+    fn release_read(&self) {
+        match self.state.get() {
+            LockState::Reading(1) => {
+                self.state.set(LockState::Unlocked);
+                self.wake_waiters();
+            }
+            LockState::Reading(n) if n > 1 => {
+                self.state.set(LockState::Reading(n - 1));
+            }
+            _ => panic!("LocalRwLock: release_read called but not in Reading state"),
+        }
+    }
+
+    fn release_write(&self) {
+        match self.state.get() {
+            LockState::Writing => {
+                self.state.set(LockState::Unlocked);
+                self.wake_waiters();
+            }
+            _ => panic!("LocalRwLock: release_write called but not in Writing state"),
+        }
+    }
+
+    fn wake_waiters(&self) {
+        // Wake writers first (priority)
+        let mut write_waiters = self.write_waiters.borrow_mut();
+        let has_writers = write_waiters.iter().any(|w| w.is_some());
+
+        if has_writers {
+            // If there are waiting writers, only wake them (they need exclusive access)
+            for waker in write_waiters.drain(..).flatten() {
+                waker.wake();
+            }
+        } else {
+            // No writers waiting, wake all readers (they can share the lock)
+            drop(write_waiters); // Release borrow before borrowing read_waiters
+            let mut read_waiters = self.read_waiters.borrow_mut();
+            for waker in read_waiters.drain(..).flatten() {
+                waker.wake();
+            }
+        }
+    }
+
+    /// Shared polling logic for all futures.
+    /// Returns Poll::Ready(()) if the lock was acquired, Poll::Pending otherwise.
+    fn poll_lock(
+        &self,
+        waiter_index: &Cell<Option<usize>>,
+        cx: &mut Context<'_>,
+        try_lock: impl FnOnce(&Self) -> bool,
+        is_write: bool,
+    ) -> Poll<()> {
+        if try_lock(self) {
+            // If we successfully acquired the lock, remove our waiter slot if we registered one
+            if let Some(index) = waiter_index.get() {
+                let waiters = if is_write {
+                    &self.write_waiters
+                } else {
+                    &self.read_waiters
+                };
+                let mut waiters = waiters.borrow_mut();
+                if index < waiters.len() {
+                    waiters[index] = None;
+                }
+            }
+            return Poll::Ready(());
+        }
+
+        // Register or update our waker in the appropriate waiters list
+        let waiters = if is_write {
+            &self.write_waiters
+        } else {
+            &self.read_waiters
+        };
+        let mut waiters = waiters.borrow_mut();
+
+        if let Some(index) = waiter_index.get() {
+            // We already have a slot, check if we need to update it
+            if index < waiters.len() {
+                if let Some(existing) = &waiters[index] {
+                    if !existing.will_wake(cx.waker()) {
+                        waiters[index] = Some(cx.waker().clone());
+                    }
+                } else {
+                    waiters[index] = Some(cx.waker().clone());
+                }
+            } else {
+                // Our slot was somehow removed, register a new one
+                let new_index = waiters.len();
+                waiters.push(Some(cx.waker().clone()));
+                waiter_index.set(Some(new_index));
+            }
+        } else {
+            // First time registering
+            let index = waiters.len();
+            waiters.push(Some(cx.waker().clone()));
+            waiter_index.set(Some(index));
+        }
+
+        Poll::Pending
+    }
+
+    /// Cleanup waiter slot on drop
+    fn cleanup_waiter(&self, waiter_index: &Cell<Option<usize>>, is_write: bool) {
+        if let Some(index) = waiter_index.get() {
+            let waiters = if is_write {
+                &self.write_waiters
+            } else {
+                &self.read_waiters
+            };
+            let mut waiters = waiters.borrow_mut();
+            if index < waiters.len() {
+                waiters[index] = None;
+            }
+        }
+    }
+}
+
+// Guards with 'static lifetime (Rc-like)
+
+/// A read guard with a `'static` lifetime, holding an `Rc` to the lock.
+pub struct LocalRwLockReadGuard<T> {
+    inner: Rc<LocalRwLockInner<T>>,
+}
+
+impl<T> LocalRwLockReadGuard<T> {
+    /// Rebuild a handle to the lock from this [`LocalRwLockReadGuard`].
+    pub fn lock_handle(me: &Self) -> LocalRwLock<T> {
+        LocalRwLock {
+            inner: me.inner.clone(),
+        }
+    }
+}
+
+impl<T> Deref for LocalRwLockReadGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.inner.value.get() }
+    }
+}
+
+impl<T> Drop for LocalRwLockReadGuard<T> {
+    fn drop(&mut self) {
+        self.inner.release_read();
+    }
+}
+
+/// A write guard with a `'static` lifetime, holding an `Rc` to the lock.
+pub struct LocalRwLockWriteGuard<T> {
+    inner: Rc<LocalRwLockInner<T>>,
+}
+
+impl<T> LocalRwLockWriteGuard<T> {
+    /// Rebuild a handle to the lock from this [`LocalRwLockWriteGuard`].
+    pub fn lock_handle(me: &Self) -> LocalRwLock<T> {
+        LocalRwLock {
+            inner: me.inner.clone(),
+        }
+    }
+}
+
+impl<T> Deref for LocalRwLockWriteGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.inner.value.get() }
+    }
+}
+
+impl<T> DerefMut for LocalRwLockWriteGuard<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.inner.value.get() }
+    }
+}
+
+impl<T> Drop for LocalRwLockWriteGuard<T> {
+    fn drop(&mut self) {
+        self.inner.release_write();
+    }
+}
+
+// Futures
+
+/// Future returned by `read_rc()`.
+pub struct ReadFuture<T> {
+    inner: Rc<LocalRwLockInner<T>>,
+    waiter_index: Cell<Option<usize>>,
+}
+
+impl<T> Future for ReadFuture<T> {
+    type Output = LocalRwLockReadGuard<T>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if self
+            .inner
+            .poll_lock(&self.waiter_index, cx, |inner| inner.try_read(), false)
+            .is_ready()
+        {
+            Poll::Ready(LocalRwLockReadGuard {
+                inner: self.inner.clone(),
+            })
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+impl<T> Drop for ReadFuture<T> {
+    fn drop(&mut self) {
+        self.inner.cleanup_waiter(&self.waiter_index, false);
+    }
+}
+
+/// Future returned by `write_rc()`.
+pub struct WriteFuture<T> {
+    inner: Rc<LocalRwLockInner<T>>,
+    waiter_index: Cell<Option<usize>>,
+}
+
+impl<T> Future for WriteFuture<T> {
+    type Output = LocalRwLockWriteGuard<T>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if self
+            .inner
+            .poll_lock(&self.waiter_index, cx, |inner| inner.try_write(), true)
+            .is_ready()
+        {
+            Poll::Ready(LocalRwLockWriteGuard {
+                inner: self.inner.clone(),
+            })
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+impl<T> Drop for WriteFuture<T> {
+    fn drop(&mut self) {
+        self.inner.cleanup_waiter(&self.waiter_index, true);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_read_write() {
+        let lock = LocalRwLock::new(42);
+
+        // Can acquire read lock
+        let guard = lock.try_read().unwrap();
+        assert_eq!(*guard, 42);
+        drop(guard);
+
+        // Can acquire write lock
+        let mut guard = lock.try_write().unwrap();
+        *guard = 100;
+        drop(guard);
+
+        // Value was updated
+        let guard = lock.try_read().unwrap();
+        assert_eq!(*guard, 100);
+    }
+
+    #[test]
+    fn test_multiple_readers() {
+        let lock = LocalRwLock::new(42);
+
+        let guard1 = lock.try_read().unwrap();
+        let guard2 = lock.try_read().unwrap();
+        let guard3 = lock.try_read().unwrap();
+
+        assert_eq!(*guard1, 42);
+        assert_eq!(*guard2, 42);
+        assert_eq!(*guard3, 42);
+
+        // Cannot acquire write lock while readers exist
+        assert!(lock.try_write().is_none());
+
+        drop(guard1);
+        assert!(lock.try_write().is_none());
+
+        drop(guard2);
+        assert!(lock.try_write().is_none());
+
+        drop(guard3);
+        // Now we can acquire write lock
+        assert!(lock.try_write().is_some());
+    }
+
+    #[test]
+    fn test_exclusive_writer() {
+        let lock = LocalRwLock::new(42);
+
+        let guard = lock.try_write().unwrap();
+
+        // Cannot acquire another write lock
+        assert!(lock.try_write().is_none());
+
+        // Cannot acquire read lock
+        assert!(lock.try_read().is_none());
+
+        drop(guard);
+
+        // Now we can acquire locks again
+        assert!(lock.try_read().is_some());
+    }
+
+    #[test]
+    fn test_arc_guards() {
+        let lock = LocalRwLock::new(42);
+
+        // Try read_rc
+        let guard = lock.try_read().unwrap();
+        assert_eq!(*guard, 42);
+        drop(guard);
+
+        // Try write_rc
+        let mut guard = lock.try_write().unwrap();
+        *guard = 100;
+        drop(guard);
+
+        let guard = lock.try_read().unwrap();
+        assert_eq!(*guard, 100);
+    }
+
+    #[test]
+    fn test_writer_priority() {
+        use std::sync::{Arc, Mutex};
+        use std::task::{Poll, Wake};
+
+        // Custom waker that tracks when it's woken
+        struct TrackingWaker {
+            name: &'static str,
+            wake_order: Arc<Mutex<Vec<&'static str>>>,
+        }
+
+        impl Wake for TrackingWaker {
+            fn wake(self: Arc<Self>) {
+                self.wake_order.lock().unwrap().push(self.name);
+            }
+        }
+
+        let lock = LocalRwLock::new(0);
+        let wake_order = Arc::new(Mutex::new(Vec::new()));
+
+        // Acquire write lock
+        let write_guard = lock.try_write().unwrap();
+
+        // Create read and write futures that will need to wait
+        let mut read_future = Box::pin(lock.read());
+        let mut write_future = Box::pin(lock.write());
+
+        // Create tracking wakers
+        let read_waker = Arc::new(TrackingWaker {
+            name: "reader",
+            wake_order: wake_order.clone(),
+        })
+        .into();
+        let mut read_cx = std::task::Context::from_waker(&read_waker);
+
+        let write_waker = Arc::new(TrackingWaker {
+            name: "writer",
+            wake_order: wake_order.clone(),
+        })
+        .into();
+        let mut write_cx = std::task::Context::from_waker(&write_waker);
+
+        // Poll both to register them as waiters
+        assert!(matches!(
+            write_future.as_mut().poll(&mut write_cx),
+            Poll::Pending
+        ));
+        assert!(matches!(
+            read_future.as_mut().poll(&mut read_cx),
+            Poll::Pending
+        ));
+
+        // Verify they're in separate queues
+        assert_eq!(
+            lock.inner
+                .write_waiters
+                .borrow()
+                .iter()
+                .filter(|w| w.is_some())
+                .count(),
+            1
+        );
+        assert_eq!(
+            lock.inner
+                .read_waiters
+                .borrow()
+                .iter()
+                .filter(|w| w.is_some())
+                .count(),
+            1
+        );
+
+        // No wakers called yet
+        assert_eq!(wake_order.lock().unwrap().len(), 0);
+
+        // Release the write lock - this should wake waiters
+        drop(write_guard);
+
+        // Verify ONLY writer was woken (not reader, since writer has priority)
+        let order = wake_order.lock().unwrap();
+        assert_eq!(
+            order.len(),
+            1,
+            "Only writer should be woken when writers are waiting"
+        );
+        assert_eq!(order[0], "writer", "Writer should be woken, not reader");
+    }
+
+    #[test]
+    fn test_readers_woken_when_no_writers() {
+        use std::sync::{Arc, Mutex};
+        use std::task::{Poll, Wake};
+
+        // Custom waker that tracks when it's woken
+        struct TrackingWaker {
+            name: String,
+            wake_order: Arc<Mutex<Vec<String>>>,
+        }
+
+        impl Wake for TrackingWaker {
+            fn wake(self: Arc<Self>) {
+                self.wake_order.lock().unwrap().push(self.name.clone());
+            }
+        }
+
+        let lock = LocalRwLock::new(0);
+        let wake_order = Arc::new(Mutex::new(Vec::new()));
+
+        // Acquire write lock
+        let write_guard = lock.try_write().unwrap();
+
+        // Create multiple read futures (no writers)
+        let mut read_future1 = Box::pin(lock.read());
+        let mut read_future2 = Box::pin(lock.read());
+
+        // Create tracking wakers
+        let read_waker1 = Arc::new(TrackingWaker {
+            name: "reader1".to_string(),
+            wake_order: wake_order.clone(),
+        })
+        .into();
+        let mut read_cx1 = std::task::Context::from_waker(&read_waker1);
+
+        let read_waker2 = Arc::new(TrackingWaker {
+            name: "reader2".to_string(),
+            wake_order: wake_order.clone(),
+        })
+        .into();
+        let mut read_cx2 = std::task::Context::from_waker(&read_waker2);
+
+        // Poll both to register them as waiters
+        assert!(matches!(
+            read_future1.as_mut().poll(&mut read_cx1),
+            Poll::Pending
+        ));
+        assert!(matches!(
+            read_future2.as_mut().poll(&mut read_cx2),
+            Poll::Pending
+        ));
+
+        // Verify they're in read queue
+        assert_eq!(
+            lock.inner
+                .read_waiters
+                .borrow()
+                .iter()
+                .filter(|w| w.is_some())
+                .count(),
+            2
+        );
+        assert_eq!(
+            lock.inner
+                .write_waiters
+                .borrow()
+                .iter()
+                .filter(|w| w.is_some())
+                .count(),
+            0
+        );
+
+        // No wakers called yet
+        assert_eq!(wake_order.lock().unwrap().len(), 0);
+
+        // Release the write lock - this should wake all readers since no writers are waiting
+        drop(write_guard);
+
+        // Verify both readers were woken
+        let order = wake_order.lock().unwrap();
+        assert_eq!(
+            order.len(),
+            2,
+            "Both readers should be woken when no writers are waiting"
+        );
+        assert!(order.contains(&"reader1".to_string()));
+        assert!(order.contains(&"reader2".to_string()));
+    }
+}
diff --git a/lib/api/src/entities/store/mod.rs b/lib/api/src/entities/store/mod.rs
new file mode 100644
index 0000000000..e1aee0709f
--- /dev/null
+++ b/lib/api/src/entities/store/mod.rs
@@ -0,0 +1,193 @@
+//! Defines the [`Store`] data type and various useful traits and data types to interact with a
+//! store.
+
+/// Defines the [`AsStoreAsync`] trait and its supporting types.
+#[cfg(feature = "experimental-async")]
+mod async_;
+#[cfg(feature = "experimental-async")]
+pub use async_::*;
+
+/// Defines the [`StoreContext`] type.
+mod context;
+
+/// Defines the [`StoreInner`] data type.
+mod inner;
+
+/// Create temporary handles to engines.
+mod store_ref;
+
+/// Single-threaded async-aware RwLock.
+#[cfg(feature = "experimental-async")]
+mod local_rwlock;
+#[cfg(feature = "experimental-async")]
+pub(crate) use local_rwlock::*;
+
+use std::{
+    boxed::Box,
+    ops::{Deref, DerefMut},
+};
+
+pub use store_ref::*;
+
+mod obj;
+pub use obj::*;
+
+use crate::{AsEngineRef, BackendEngine, Engine, EngineRef};
+pub(crate) use context::*;
+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()
+    }
+
+    #[cfg(feature = "experimental-async")]
+    /// Transforms this store into a [`StoreAsync`] which can be used
+    /// to invoke [`Function::call_async`](crate::Function::call_async).
+    pub fn into_async(self) -> StoreAsync {
+        StoreAsync {
+            id: self.id(),
+            inner: LocalRwLock::new(self.inner),
+        }
+    }
+}
+
+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..215ec2b8a5
--- /dev/null
+++ b/lib/api/src/entities/store/obj.rs
@@ -0,0 +1,102 @@
+use wasmer_types::StoreId;
+
+use crate::{BackendStore, macros::backend::match_rt};
+
+/// 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(a), Self::Sys(b)) => a.id() == b.id(),
+            #[cfg(feature = "wamr")]
+            (Self::Wamr(a), Self::Wamr(b)) => a.id() == b.id(),
+            #[cfg(feature = "v8")]
+            (Self::V8(a), Self::V8(b)) => a.id() == b.id(),
+            #[cfg(feature = "js")]
+            (Self::Js(a), Self::Js(b)) => a.id() == b.id(),
+
+            #[cfg(feature = "jsc")]
+            (Self::Jsc(a), Self::Jsc(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..42ad59ec12
--- /dev/null
+++ b/lib/api/src/entities/store/store_ref.rs
@@ -0,0 +1,172 @@
+use std::ops::{Deref, DerefMut};
+
+use super::{StoreObjects, inner::StoreInner};
+use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
+#[cfg(feature = "experimental-async")]
+use crate::{AsStoreAsync, StoreAsync};
+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: unsafe { &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<'_>;
+
+    /// Returns a [`StoreAsync`] if the current
+    /// context is asynchronous. The store will be locked since
+    /// it's already active in the current context, but can be used
+    /// to spawn new coroutines via
+    /// [`Function::call_async`](crate::Function::call_async).
+    #[cfg(feature = "experimental-async")]
+    fn as_store_async(&self) -> Option<impl AsStoreAsync + 'static> {
+        let id = self.as_store_ref().inner.objects.id();
+        StoreAsync::from_context(id)
+    }
+}
+
+/// 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..13e6f86e1d
--- /dev/null
+++ b/lib/api/src/entities/table/inner.rs
@@ -0,0 +1,272 @@
+use wasmer_types::TableType;
+
+use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    store::BackendStore,
+    vm::{VMExtern, VMExternTable},
+};
+/// 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::{Instance, Module, Store, Table, TableType, Type, Value, imports};
+
+        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..bcb05aa5e2 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::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
+    error::RuntimeError,
+    store::BackendStore,
+    vm::{VMExtern, VMExternTable},
+};
 
 /// 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::{Instance, Module, Store, Table, TableType, Type, Value, imports};
+
+        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..5d05c4bbd1
--- /dev/null
+++ b/lib/api/src/entities/tag/inner.rs
@@ -0,0 +1,115 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternTag},
+};
+
+/// 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..794d0b5d9c
--- /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::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
+    vm::{VMExtern, VMExternTag},
+};
+
+/// 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..8578b96051
--- /dev/null
+++ b/lib/api/src/entities/trap.rs
@@ -0,0 +1,147 @@
+use std::{any::Any, error::Error, fmt::Debug};
+
+#[cfg(feature = "sys")]
+use crate::BackendException;
+use crate::{Exception, RuntimeError, macros::backend::match_rt};
+
+/// 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>()
+        })
+    }
+
+    /// Returns true if the trap is an exception
+    #[inline]
+    pub fn is_exception(&self) -> bool {
+        match_rt!(on self => s {
+            s.is_exception()
+        })
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    #[inline]
+    pub fn to_exception(&self) -> Option<Exception> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Sys(e))),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Wamr(e))),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Wasmi(e))),
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::V8(e))),
+            #[cfg(feature = "js")]
+            Self::Js(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Js(e))),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s
+                .to_exception_ref()
+                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Jsc(e))),
+        }
+    }
+}
+
+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 56%
rename from lib/api/src/value.rs
rename to lib/api/src/entities/value.rs
index 15ec16edea..06ec15ec82 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::{
+    AsStoreRef, Tag,
+    entities::{Exception, ExternRef, Function},
+    vm::{VMExceptionRef, VMExternRef, VMFuncRef},
+};
 
 /// 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<Exception>),
 }
 
 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 { exnref: 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,144 @@ 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::I32 => Self::I32(unsafe { raw.i32 }),
+            Type::I64 => Self::I64(unsafe { raw.i64 }),
+            Type::F32 => Self::F32(unsafe { raw.f32 }),
+            Type::F64 => Self::F64(unsafe { raw.f64 }),
+            Type::V128 => Self::V128(unsafe { raw.u128 }),
+            Type::FuncRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::FuncRef({
+                    unsafe { crate::backend::sys::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Sys) }
+                        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::FuncRef({
+                    unsafe {
+                        crate::backend::wamr::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wamr)
+                    }
+                    .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::FuncRef({
+                    unsafe {
+                        crate::backend::wasmi::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wasmi)
+                    }
+                    .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::FuncRef({
+                    unsafe { crate::backend::v8::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::V8) }
+                        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::FuncRef({
+                    unsafe { crate::backend::js::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Js) }
+                        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::FuncRef({
+                    unsafe { crate::backend::jsc::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Jsc) }
+                        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
+                }),
+            },
+            Type::ExternRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::sys::vm::VMExternRef::from_raw(raw).map(VMExternRef::Sys)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::wamr::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wamr)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::wasmi::vm::VMExternRef::from_raw(raw)
+                            .map(VMExternRef::Wasmi)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::v8::vm::VMExternRef::from_raw(raw).map(VMExternRef::V8)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::js::vm::VMExternRef::from_raw(raw).map(VMExternRef::Js)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::ExternRef({
+                    unsafe {
+                        crate::backend::jsc::vm::VMExternRef::from_raw(raw).map(VMExternRef::Jsc)
+                    }
+                    .map(|f| unsafe { ExternRef::from_vm_externref(store, f) })
+                }),
+            },
+            Type::ExceptionRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::ExceptionRef(
+                    unsafe {
+                        crate::backend::sys::vm::VMExceptionRef::from_raw(
+                            store.objects_mut().id(),
+                            raw,
+                        )
+                    }
+                    .map(VMExceptionRef::Sys)
+                    .map(Exception::from_vm_exceptionref),
+                ),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::ExceptionRef(
+                    unsafe { crate::backend::wamr::vm::VMExceptionRef::from_raw(raw) }
+                        .map(VMExceptionRef::Wamr)
+                        .map(Exception::from_vm_exceptionref),
+                ),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::ExceptionRef(
+                    unsafe { crate::backend::wasmi::vm::VMExceptionRef::from_raw(raw) }
+                        .map(VMExceptionRef::Wasmi)
+                        .map(Exception::from_vm_exceptionref),
+                ),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::ExceptionRef(
+                    unsafe { crate::backend::v8::vm::VMExceptionRef::from_raw(raw) }
+                        .map(VMExceptionRef::V8)
+                        .map(Exception::from_vm_exceptionref),
+                ),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::ExceptionRef(
+                    unsafe { crate::backend::js::vm::VMExceptionRef::from_raw(raw) }
+                        .map(VMExceptionRef::Js)
+                        .map(Exception::from_vm_exceptionref),
+                ),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::ExceptionRef(
+                    unsafe { crate::backend::jsc::vm::VMExceptionRef::from_raw(raw) }
+                        .map(VMExceptionRef::Jsc)
+                        .map(Exception::from_vm_exceptionref),
+                ),
+            },
         }
     }
 
@@ -141,8 +265,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 +285,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 +397,25 @@ impl From<Option<ExternRef>> for Value {
     }
 }
 
+impl From<Exception> for Value {
+    fn from(val: Exception) -> Self {
+        Self::ExceptionRef(Some(val))
+    }
+}
+
+impl From<Option<Exception>> for Value {
+    fn from(val: Option<Exception>) -> 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 +487,17 @@ impl TryFrom<Value> for Option<ExternRef> {
     }
 }
 
+impl TryFrom<Value> for Option<Exception> {
+    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 69%
rename from lib/api/src/errors.rs
rename to lib/api/src/error.rs
index 88c596db38..f80ffb67da 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::{AsStoreMut, AsStoreRef, BackendTrap as Trap, Exception, Value};
 
 /// The WebAssembly.LinkError object indicates an error during
 /// module instantiation (besides traps from the start function).
@@ -25,9 +18,9 @@ pub enum LinkError {
     #[cfg_attr(feature = "std", error("Error while importing {0:?}.{1:?}: {2}"))]
     Import(String, String, ImportError),
 
-    /// A trap ocurred during linking.
+    /// A trap occurred during linking.
     #[cfg_attr(feature = "std", error("RuntimeError occurred during linking: {0}"))]
-    Trap(#[source] RuntimeError),
+    Trap(#[cfg_attr(feature = "std", source)] RuntimeError),
     /// Insufficient resources available for linking.
     #[cfg_attr(feature = "std", error("Insufficient resources: {0}"))]
     Resource(String),
@@ -44,7 +37,7 @@ pub enum LinkError {
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "std", derive(Error))]
 pub enum InstantiationError {
-    /// A linking ocurred during instantiation.
+    /// A linking occurred during instantiation.
     #[cfg_attr(feature = "std", error(transparent))]
     Link(LinkError),
 
@@ -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)
     }
 }
@@ -160,6 +153,26 @@ impl RuntimeError {
         }
     }
 
+    /// Creates a `RuntimeError` containing an exception.
+    ///
+    /// If this error is returned from an imported function, the exception
+    /// will be thrown in the WebAssembly code instead of the usual trapping.
+    pub fn exception(ctx: &impl AsStoreRef, exception: Exception) -> Self {
+        let exnref = exception.vm_exceptionref();
+        let store = ctx.as_store_ref();
+        match store.inner.objects {
+            #[cfg(feature = "sys")]
+            crate::StoreObjects::Sys(ref store_objects) => {
+                crate::backend::sys::vm::Trap::uncaught_exception(
+                    exnref.as_sys().clone(),
+                    store_objects,
+                )
+                .into()
+            }
+            _ => panic!("exceptions are only supported in the `sys` backend"),
+        }
+    }
+
     /// Returns a reference the `message` stored in `Trap`.
     pub fn message(&self) -> String {
         if let Some(trap_code) = self.inner.trap_code {
@@ -205,33 +218,40 @@ impl RuntimeError {
     pub fn is<T: std::error::Error + 'static>(&self) -> bool {
         self.inner.source.is::<T>()
     }
-}
 
-impl fmt::Debug for RuntimeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("RuntimeError")
-            .field("source", &self.inner.source)
-            .field("wasm_trace", &self.inner.wasm_trace)
-            .finish()
+    /// Returns true if the `RuntimeError` is an uncaught exception.
+    pub fn is_exception(&self) -> bool {
+        self.inner.source.is_exception()
     }
-}
 
-impl fmt::Display for RuntimeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "RuntimeError: {}", self.message())?;
-        let trace = self.trace();
+    /// If the `RuntimeError` is an uncaught exception, returns it.
+    pub fn to_exception(&self) -> Option<Exception> {
+        self.inner.source.to_exception()
+    }
+
+    /// Returns a displayable version of the `RuntimeError` that also shows exception payloads.
+    pub fn display<'a>(&'a self, store: &'a mut impl AsStoreMut) -> RuntimeErrorDisplay<'a> {
+        if let Some(exception) = self.to_exception() {
+            RuntimeErrorDisplay::Exception(exception.payload(store), self.trace())
+        } else {
+            RuntimeErrorDisplay::Other(self)
+        }
+    }
+
+    /// Write the WASM trace to the given formatter, if we have one.
+    pub fn write_trace(trace: &[FrameInfo], f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if trace.is_empty() {
             return Ok(());
         }
-        for frame in self.trace().iter() {
+        for frame in trace.iter() {
             let name = frame.module_name();
             let func_index = frame.func_index();
             writeln!(f)?;
             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>")?,
             }
@@ -245,6 +265,52 @@ impl fmt::Display for RuntimeError {
         }
         Ok(())
     }
+
+    pub(crate) fn from_dyn(err: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        match err.downcast::<Self>() {
+            Ok(runtime_error) => *runtime_error,
+            Err(error) => Trap::user(error),
+        }
+    }
+}
+
+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)
+            .finish()
+    }
+}
+
+impl std::fmt::Display for RuntimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "RuntimeError: {}", self.message())?;
+        Self::write_trace(self.trace(), f)
+    }
+}
+
+/// A displayable version of the `RuntimeError` that also shows exception payloads.
+pub enum RuntimeErrorDisplay<'a> {
+    /// The error is an uncaught exception, with its payload and trace.
+    Exception(Vec<Value>, &'a [FrameInfo]),
+    /// The error is not an exception, just display it.
+    Other(&'a RuntimeError),
+}
+
+impl std::fmt::Display for RuntimeErrorDisplay<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RuntimeErrorDisplay::Exception(payload, trace) => {
+                write!(f, "Uncaught exception")?;
+                if !payload.is_empty() {
+                    write!(f, " with payload: {payload:?}")?;
+                }
+                RuntimeError::write_trace(trace, f)
+            }
+            RuntimeErrorDisplay::Other(err) => write!(f, "{err}"),
+        }
+    }
 }
 
 impl std::error::Error for RuntimeError {
@@ -258,7 +324,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/as_js.rs b/lib/api/src/jsc/as_js.rs
deleted file mode 100644
index 77175fc121..0000000000
--- a/lib/api/src/jsc/as_js.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-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;
-
-/// Convert the given type to a [`JsValue`].
-pub trait AsJs: 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;
-    /// Convert the given type to a [`JsValue`].
-    fn from_jsvalue(
-        store: &mut impl AsStoreMut,
-        type_: &Self::DefinitionType,
-        value: &JSValue,
-    ) -> Result<Self, JSValue>;
-}
-
-#[inline]
-pub fn param_from_js(context: &JSContext, ty: &Type, js_val: &JSValue) -> Value {
-    match ty {
-        Type::I32 => Value::I32(js_val.to_number(&context).unwrap() as _),
-        Type::I64 => {
-            let number = if js_val.is_number(&context) {
-                js_val.to_number(&context).unwrap() as _
-            } else {
-                js_val
-                    .to_string(&context)
-                    .unwrap()
-                    .to_string()
-                    .parse()
-                    .unwrap()
-            };
-            Value::I64(number)
-        }
-        Type::F32 => Value::F32(js_val.to_number(&context).unwrap() as _),
-        Type::F64 => Value::F64(js_val.to_number(&context).unwrap()),
-        Type::V128 => {
-            let number = if js_val.is_number(&context) {
-                js_val.to_number(&context).unwrap() as _
-            } else {
-                js_val
-                    .to_string(&context)
-                    .unwrap()
-                    .to_string()
-                    .parse()
-                    .unwrap()
-            };
-            Value::V128(number)
-        }
-        Type::ExternRef | Type::FuncRef => unimplemented!(
-            "The type `{:?}` is not yet supported in the JS Function API",
-            ty
-        ),
-    }
-}
-
-impl AsJs for Value {
-    type DefinitionType = Type;
-
-    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JSValue {
-        let engine = store.as_store_ref();
-        let context = engine.jsc().context();
-        match self {
-            Self::I32(i) => JSValue::number(&context, *i as _),
-            // JavascriptCore will fail with:
-            // new WebAssembly.Global({value: "i64", mutable: false}, 3);
-            // But will succeed with
-            // new WebAssembly.Global({value: "i64", mutable: false}, "3");
-            Self::I64(i) => JSValue::string(&context, (*i).to_string()),
-            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(None) => JSValue::null(&context),
-            Self::ExternRef(_) => unimplemented!(),
-        }
-    }
-
-    fn from_jsvalue(
-        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))
-    }
-}
-
-impl AsJs for Extern {
-    type DefinitionType = ExternType;
-
-    fn as_jsvalue(&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(),
-        }
-    }
-
-    fn from_jsvalue(
-        store: &mut impl AsStoreMut,
-        extern_type: &Self::DefinitionType,
-        val: &JSValue,
-    ) -> Result<Self, JSValue> {
-        // Note: this function do a soft check over the type
-        // We only check the "kind" of Extern, but nothing else
-        // unimplemented!();
-        let engine = store.as_store_mut();
-        let context = engine.jsc().context();
-        match extern_type {
-            ExternType::Function(function_type) => {
-                let obj_val = val.to_object(&context).unwrap();
-                Ok(Self::Function(Function::from_vm_extern(
-                    store,
-                    VMFunction::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(
-                    store,
-                    VMGlobal::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(
-                    store,
-                    VMMemory::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(
-                    store,
-                    VMTable::new(obj_val, table_type.clone()),
-                )))
-            }
-        }
-    }
-}
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/global.rs b/lib/api/src/jsc/externals/global.rs
deleted file mode 100644
index ca83f52992..0000000000
--- a/lib/api/src/jsc/externals/global.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-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};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Global {
-    pub(crate) handle: VMGlobal,
-}
-
-// 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 {
-        VMExtern::Global(self.handle.clone())
-    }
-
-    /// 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> {
-        if !val.is_from_store(store) {
-            return Err(RuntimeError::new("cross-`Store` values are not supported"));
-        }
-        let global_ty = GlobalType {
-            mutability,
-            ty: val.ty(),
-        };
-        let store_mut = store.as_store_mut();
-        let engine = store_mut.engine();
-        let context = engine.0.context();
-
-        let mut descriptor = JSObject::new(&context);
-        let type_str = match val.ty() {
-            Type::I32 => "i32",
-            Type::I64 => "i64",
-            Type::F32 => "f32",
-            Type::F64 => "f64",
-            ty => unimplemented!(
-                "The type: {:?} is not yet supported in the JS Global API",
-                ty
-            ),
-        };
-        // This is the value type as string, even though is incorrectly called "value"
-        // in the JS API.
-        descriptor.set_property(
-            &context,
-            "value".to_string(),
-            JSValue::string(&context, type_str.to_string()),
-        );
-        descriptor.set_property(
-            &context,
-            "mutable".to_string(),
-            JSValue::boolean(&context, mutability.is_mutable()),
-        );
-
-        let value: JSValue = val.as_jsvalue(&store_mut);
-        let js_global = engine
-            .0
-            .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))
-    }
-
-    pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
-        self.handle.ty
-    }
-
-    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 value = self
-            .handle
-            .global
-            .get_property(&context, "value".to_string());
-        param_from_js(&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 engine = store_mut.engine();
-        let context = engine.0.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 fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
-    }
-}
diff --git a/lib/api/src/jsc/externals/memory.rs b/lib/api/src/jsc/externals/memory.rs
deleted file mode 100644
index bcb9361866..0000000000
--- a/lib/api/src/jsc/externals/memory.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-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;
-
-use tracing::warn;
-
-use wasmer_types::{Pages, WASM_PAGE_SIZE};
-
-use super::memory_view::MemoryView;
-
-pub use wasmer_types::MemoryError;
-
-#[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 vm_memory = VMMemory::new(Self::js_memory_from_type(store, &ty)?, ty);
-        Ok(Self::from_vm_extern(store, vm_memory))
-    }
-
-    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()),
-            );
-        }
-        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)))
-    }
-
-    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
-        Self::from_vm_extern(new_store, memory)
-    }
-
-    pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        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 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.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))
-    }
-
-    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: VMMemory) -> Self {
-        Self { handle: internal }
-    }
-
-    /// 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.duplicate(store)
-    }
-
-    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::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)?;
-        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 { 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(mem::size_of::<T>());
-        *dst = dst.add(mem::size_of::<T>());
-        *len -= 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(mem::size_of::<T>());
-        *dst = dst.add(mem::size_of::<T>());
-        *len -= 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/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/externals/table.rs b/lib/api/src/jsc/externals/table.rs
deleted file mode 100644
index 24159773b1..0000000000
--- a/lib/api/src/jsc/externals/table.rs
+++ /dev/null
@@ -1,158 +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 rusty_jsc::{JSObject, JSValue};
-
-#[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: &JSObject) -> Result<(), RuntimeError> {
-    unimplemented!();
-    // table.table.set(item_index, item).map_err(|e| e.into())
-}
-
-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 {
-    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 context = engine.0.context();
-
-        let mut descriptor = JSObject::new(&context);
-        descriptor.set_property(
-            &context,
-            "initial".to_string(),
-            JSValue::number(&context, ty.minimum.into()),
-        );
-        if let Some(max) = ty.maximum {
-            descriptor.set_property(
-                &context,
-                "maximum".to_string(),
-                JSValue::number(&context, max.into()),
-            );
-        }
-        descriptor.set_property(
-            &context,
-            "element".to_string(),
-            JSValue::string(&context, "anyfunc".to_string()),
-        );
-
-        let js_table = engine
-            .0
-            .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))
-    }
-
-    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> {
-        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(
-        &self,
-        store: &mut impl AsStoreMut,
-        index: u32,
-        val: Value,
-    ) -> Result<(), RuntimeError> {
-        unimplemented!();
-        // let item = get_function(store, val)?;
-        // set_table_item(&self.handle, index, &item)
-    }
-
-    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();
-        self.handle
-            .table
-            .get_property(&context, "length".to_string())
-            .to_number(&context)
-            .unwrap() as _
-    }
-
-    pub fn grow(
-        &self,
-        store: &mut impl AsStoreMut,
-        delta: u32,
-        _init: Value,
-    ) -> Result<u32, RuntimeError> {
-        let store_mut = store.as_store_mut();
-        let engine = store_mut.engine();
-        let context = engine.0.context();
-        let func = self
-            .handle
-            .table
-            .get_property(&context, "grow".to_string())
-            .to_object(&context)
-            .unwrap();
-        match func.call(
-            &context,
-            Some(&self.handle.table),
-            &[JSValue::number(&context, delta as _)],
-        ) {
-            Ok(val) => Ok(val.to_number(&context).unwrap() as _),
-            Err(e) => Err(<JSValue as Into<RuntimeError>>::into(e)),
-        }
-    }
-
-    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/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..8bec14afbd
--- 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))
 //!     "#;
@@ -69,13 +72,17 @@
 //!
 //! * **Pluggable compilers** — A compiler is used by the engine to
 //!   transform WebAssembly into executable code:
-//!   * [`wasmer-compiler-singlepass`] provides a fast compilation-time
+//!   * [`wasmer-compiler-singlepass`](https://docs.rs/wasmer-compiler-singlepass/) provides a fast compilation-time
 //!     but an unoptimized runtime speed,
-//!   * [`wasmer-compiler-cranelift`] provides the right balance between
+//!   * [`wasmer-compiler-cranelift`](https://docs.rs/wasmer-compiler-cranelift/) provides the right balance between
 //!     compilation-time and runtime performance, useful for development,
-//!   * [`wasmer-compiler-llvm`] provides a deeply optimized executable
+//!   * [`wasmer-compiler-llvm`](https://docs.rs/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)"
@@ -287,15 +302,15 @@
 //! - `cranelift`
 #![cfg_attr(feature = "cranelift", doc = "(enabled),")]
 #![cfg_attr(not(feature = "cranelift"), doc = "(disabled),")]
-//!   enables Wasmer's [Cranelift compiler][wasmer-compiler-cranelift],
+//!   enables Wasmer's [`Cranelift` compiler](https://docs.rs/wasmer-compiler-cranelift),
 //! - `llvm`
 #![cfg_attr(feature = "llvm", doc = "(enabled),")]
 #![cfg_attr(not(feature = "llvm"), doc = "(disabled),")]
-//!   enables Wasmer's [LLVM compiler][wasmer-compiler-lvm],
+//!   enables Wasmer's [`LLVM` compiler](https://docs.rs/wasmer-compiler-llvm),
 //! - `singlepass`
 #![cfg_attr(feature = "singlepass", doc = "(enabled),")]
 #![cfg_attr(not(feature = "singlepass"), doc = "(disabled),")]
-//!   enables Wasmer's [Singlepass compiler][wasmer-compiler-singlepass],
+//!   enables Wasmer's [`Singlepass` compiler](https://docs.rs/wasmer-compiler-singlepass),
 //! - `wat`
 #![cfg_attr(feature = "wat", doc = "(enabled),")]
 #![cfg_attr(not(feature = "wat"), doc = "(disabled),")]
@@ -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,165 @@
 //! [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.");
+macro_rules! cfg_compiler {
+    ($($item:item)*) => {
+        $(
+            #[cfg(any(
+                feature = "cranelift",
+                feature = "singlepass",
+                feature = "llvm",
+                feature = "js",
+                feature = "jsc",
+                feature = "wamr",
+                feature = "v8",
+                feature = "wasmi",
+                feature = "headless"
+            ))]
+            $item
+        )*
+    };
+}
 
-#[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"))]
+#[cfg(not(any(
+    feature = "singlepass",
+    feature = "cranelift",
+    feature = "llvm",
+    feature = "wamr",
+    feature = "wasmi",
+    feature = "v8",
+    feature = "js",
+    feature = "jsc",
+    feature = "headless",
+)))]
 compile_error!(
-    "Cannot have both `sys` and `jsc` features enabled at the same time. Please, pick one."
+    "wasmer requires enabling at least one backend feature: `singlepass`, `cranelift`, `llvm`, `wamr`, `wasmi`, `v8`, `js`, `jsc` or `headless`."
 );
 
-#[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(all(
+    feature = "sys",
+    not(any(
+        feature = "singlepass",
+        feature = "cranelift",
+        feature = "llvm",
+        feature = "headless"
+    ))
+))]
 compile_error!(
-    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasi`)."
+    "the `sys` feature requires enabling at least one compiler backend: `singlepass`, `cranelift`, `llvm`, or `headless`."
 );
 
-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_compiler! {
+    mod utils;
+    pub use utils::*;
+    pub use entities::memory::{MemoryView, location::MemoryLocation};
+    mod error;
+    pub use error::*;
+    pub use entities::*;
+    mod backend;
+    pub use backend::*;
+    mod vm;
+}
 
-#[cfg(any(feature = "wasm-types-polyfill", feature = "jsc"))]
-mod module_info_polyfill;
-
-#[cfg(feature = "sys")]
-/// sys
-pub mod sys;
-
-#[cfg(feature = "sys")]
-pub use sys::*;
-
-#[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;
-
-#[cfg(feature = "js")]
-mod js;
-
-#[cfg(feature = "js")]
-pub use js::*;
-
-#[cfg(feature = "jsc")]
-mod jsc;
-
-#[cfg(feature = "jsc")]
-pub use jsc::*;
+// TODO: cannot be placed into cfg_compiler due to: error: `inner` is ambiguous
+#[cfg(any(
+    feature = "cranelift",
+    feature = "singlepass",
+    feature = "llvm",
+    feature = "js",
+    feature = "jsc",
+    feature = "wamr",
+    feature = "v8",
+    feature = "wasmi",
+    feature = "headless",
+))]
+mod entities;
 
-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::{
+    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, WASM_MAX_PAGES, WASM_MIN_PAGES,
+    WASM_PAGE_SIZE, WasmError, WasmResult, is_wasm,
 };
-#[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/function.rs b/lib/api/src/sys/externals/function.rs
deleted file mode 100644
index 41c292f90c..0000000000
--- a/lib/api/src/sys/externals/function.rs
+++ /dev/null
@@ -1,661 +0,0 @@
-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};
-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,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Function {
-    pub(crate) handle: StoreHandle<VMFunction>,
-}
-
-impl From<StoreHandle<VMFunction>> for Function {
-    fn from(handle: StoreHandle<VMFunction>) -> Self {
-        Self { handle }
-    }
-}
-
-impl Function {
-    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 function_type = ty.into();
-        let func_ty = function_type.clone();
-        let func_env = env.clone();
-        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)));
-                }
-                let store_mut = StoreMut::from_raw(raw_store as *mut StoreInner);
-                let env = FunctionEnvMut {
-                    store_mut,
-                    func_env: func_env.clone(),
-                };
-                let returns = func(env, &args)?;
-
-                // We need to dynamically check that the returns
-                // match the expected types, as well as expected length.
-                let return_types = returns.iter().map(|ret| ret.ty());
-                if return_types.ne(func_ty.results().iter().copied()) {
-                    return Err(RuntimeError::new(format!(
-                        "Dynamic function returned wrong signature. Expected {:?} but got {:?}",
-                        func_ty.results(),
-                        returns.iter().map(|ret| ret.ty())
-                    )));
-                }
-                for (i, ret) in returns.iter().enumerate() {
-                    *values_vec.add(i) = ret.as_raw(&store);
-                }
-            }
-            Ok(())
-        };
-        let mut host_data = Box::new(VMDynamicFunctionContext {
-            address: std::ptr::null(),
-            ctx: DynamicFunction { func: wrapper },
-        });
-        host_data.address = host_data.ctx.func_body_ptr();
-
-        // We don't yet have the address with the Wasm ABI signature.
-        // The engine linker will replace the address with one pointing to a
-        // generated dynamic trampoline.
-        let func_ptr = std::ptr::null() as VMFunctionCallback;
-        let type_index = store
-            .as_store_mut()
-            .engine()
-            .0
-            .register_signature(&function_type);
-        let vmctx = VMFunctionContext {
-            host_env: host_data.as_ref() as *const _ as *mut c_void,
-        };
-        let call_trampoline = host_data.ctx.call_trampoline_address();
-        let anyfunc = VMCallerCheckedAnyfunc {
-            func_ptr,
-            type_index,
-            vmctx,
-            call_trampoline,
-        };
-
-        let vm_function = VMFunction {
-            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
-            kind: VMFunctionKind::Dynamic,
-            signature: function_type,
-            host_data,
-        };
-        Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_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
-    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 host_data = Box::new(StaticFunction {
-            raw_store: store.as_store_mut().as_raw() as *mut u8,
-            env,
-            func,
-        });
-        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
-
-        let type_index = store
-            .as_store_mut()
-            .engine()
-            .0
-            .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();
-        let anyfunc = VMCallerCheckedAnyfunc {
-            func_ptr,
-            type_index,
-            vmctx,
-            call_trampoline,
-        };
-
-        let vm_function = VMFunction {
-            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
-            kind: VMFunctionKind::Static,
-            signature: function_type,
-            host_data,
-        };
-        Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
-        }
-    }
-
-    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,
-    {
-        let func_ptr = func.function_callback();
-        let host_data = Box::new(StaticFunction {
-            raw_store: store.as_store_mut().as_raw() as *mut u8,
-            env: env.clone(),
-            func,
-        });
-        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
-
-        let type_index = store
-            .as_store_mut()
-            .engine()
-            .0
-            .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();
-        let anyfunc = VMCallerCheckedAnyfunc {
-            func_ptr,
-            type_index,
-            vmctx,
-            call_trampoline,
-        };
-
-        let vm_function = VMFunction {
-            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
-            kind: VMFunctionKind::Static,
-            signature: function_type,
-            host_data,
-        };
-        Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
-        }
-    }
-
-    pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
-        self.handle
-            .get(store.as_store_ref().objects())
-            .signature
-            .clone()
-    }
-
-    fn call_wasm(
-        &self,
-        store: &mut impl AsStoreMut,
-        trampoline: VMTrampoline,
-        params: &[Value],
-        results: &mut [Value],
-    ) -> Result<(), RuntimeError> {
-        let format_types_for_error_message = |items: &[Value]| {
-            items
-                .iter()
-                .map(|param| param.ty().to_string())
-                .collect::<Vec<String>>()
-                .join(", ")
-        };
-        // TODO: Avoid cloning the signature here, it's expensive.
-        let signature = self.ty(store);
-        if signature.params().len() != params.len() {
-            return Err(RuntimeError::new(format!(
-                "Parameters of type [{}] did not match signature {}",
-                format_types_for_error_message(params),
-                &signature
-            )));
-        }
-        if signature.results().len() != results.len() {
-            return Err(RuntimeError::new(format!(
-                "Results of type [{}] did not match signature {}",
-                format_types_for_error_message(results),
-                &signature,
-            )));
-        }
-
-        let mut values_vec = vec![RawValue { i32: 0 }; max(params.len(), results.len())];
-
-        // Store the argument values into `values_vec`.
-        let param_tys = signature.params().iter();
-        for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) {
-            if arg.ty() != *ty {
-                let param_types = format_types_for_error_message(params);
-                return Err(RuntimeError::new(format!(
-                    "Parameters of type [{}] did not match signature {}",
-                    param_types, &signature,
-                )));
-            }
-            if !arg.is_from_store(store) {
-                return Err(RuntimeError::new("cross-`Store` values are not supported"));
-            }
-            *slot = arg.as_raw(store);
-        }
-
-        // Invoke the call
-        self.call_wasm_raw(store, trampoline, values_vec, results)?;
-        Ok(())
-    }
-
-    fn call_wasm_raw(
-        &self,
-        store: &mut impl AsStoreMut,
-        trampoline: VMTrampoline,
-        mut params: Vec<RawValue>,
-        results: &mut [Value],
-    ) -> Result<(), RuntimeError> {
-        // Call the trampoline.
-        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 storeref = store.as_store_ref();
-                let vm_function = self.handle.get(storeref.objects());
-                let config = storeref.engine().tunables().vmconfig();
-                r = unsafe {
-                    wasmer_call_trampoline(
-                        store.as_store_ref().signal_handler(),
-                        config,
-                        vm_function.anyfunc.as_ptr().as_ref().vmctx,
-                        trampoline,
-                        vm_function.anyfunc.as_ptr().as_ref().func_ptr,
-                        params.as_mut_ptr() as *mut u8,
-                    )
-                };
-                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;
-            }
-            r
-        };
-        if let Err(error) = result {
-            return Err(error.into());
-        }
-
-        // Load the return values out of `values_vec`.
-        let signature = self.ty(store);
-        for (index, &value_type) in signature.results().iter().enumerate() {
-            unsafe {
-                results[index] = Value::from_raw(store, value_type, params[index]);
-            }
-        }
-
-        Ok(())
-    }
-
-    pub fn result_arity(&self, store: &impl AsStoreRef) -> usize {
-        self.ty(store).results().len()
-    }
-
-    pub fn call(
-        &self,
-        store: &mut impl AsStoreMut,
-        params: &[Value],
-    ) -> Result<Box<[Value]>, RuntimeError> {
-        let trampoline = unsafe {
-            self.handle
-                .get(store.as_store_ref().objects())
-                .anyfunc
-                .as_ptr()
-                .as_ref()
-                .call_trampoline
-        };
-        let mut results = vec![Value::null(); self.result_arity(store)];
-        self.call_wasm(store, trampoline, params, &mut results)?;
-        Ok(results.into_boxed_slice())
-    }
-
-    #[doc(hidden)]
-    #[allow(missing_docs)]
-    pub 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())
-                .anyfunc
-                .as_ptr()
-                .as_ref()
-                .call_trampoline
-        };
-        let mut results = vec![Value::null(); self.result_arity(store)];
-        self.call_wasm_raw(store, trampoline, params, &mut results)?;
-        Ok(results.into_boxed_slice())
-    }
-
-    pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
-        let vm_function = self.handle.get(store.as_store_ref().objects());
-        if vm_function.kind == VMFunctionKind::Dynamic {
-            panic!("dynamic functions cannot be used in tables or as funcrefs");
-        }
-        VMFuncRef(vm_function.anyfunc.as_ptr())
-    }
-
-    pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
-        let signature = store
-            .as_store_ref()
-            .engine()
-            .0
-            .lookup_signature(funcref.0.as_ref().type_index)
-            .expect("Signature not found in store");
-        let vm_function = VMFunction {
-            anyfunc: MaybeInstanceOwned::Instance(funcref.0),
-            signature,
-            // All functions in tables are already Static (as dynamic functions
-            // are converted to use the trampolines with static signatures).
-            kind: wasmer_vm::VMFunctionKind::Static,
-            host_data: Box::new(()),
-        };
-        Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_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)
-            },
-        }
-    }
-
-    /// Checks whether this `Function` can be used with 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::Function(self.handle.internal_handle())
-    }
-}
-
-/// Host state for a dynamic function.
-pub(crate) struct DynamicFunction<F> {
-    func: F,
-}
-
-impl<F> DynamicFunction<F>
-where
-    F: Fn(*mut RawValue) -> Result<(), RuntimeError> + 'static,
-{
-    // This function wraps our func, to make it compatible with the
-    // reverse trampoline signature
-    unsafe extern "C" fn func_wrapper(
-        this: &mut VMDynamicFunctionContext<Self>,
-        values_vec: *mut RawValue,
-    ) {
-        let result =
-            on_host_stack(|| panic::catch_unwind(AssertUnwindSafe(|| (this.ctx.func)(values_vec))));
-
-        match result {
-            Ok(Ok(())) => {}
-            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
-            Err(panic) => resume_panic(panic),
-        }
-    }
-
-    fn func_body_ptr(&self) -> VMFunctionCallback {
-        Self::func_wrapper as VMFunctionCallback
-    }
-
-    fn call_trampoline_address(&self) -> VMTrampoline {
-        Self::call_trampoline
-    }
-
-    unsafe extern "C" fn call_trampoline(
-        vmctx: *mut VMContext,
-        _body: VMFunctionCallback,
-        args: *mut RawValue,
-    ) {
-        // The VMFunctionCallback is null here: it is only filled in later
-        // by the engine linker.
-        let dynamic_function = &mut *(vmctx as *mut VMDynamicFunctionContext<Self>);
-        Self::func_wrapper(dynamic_function, args);
-    }
-}
-
-/// Represents a low-level Wasm static host function. See
-/// [`crate::Function::new_typed`] and
-/// [`crate::Function::new_typed_with_env`] to learn more.
-pub(crate) struct StaticFunction<F, T> {
-    pub(crate) raw_store: *mut u8,
-    pub(crate) env: FunctionEnv<T>,
-    pub(crate) func: F,
-}
-
-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
-            where
-                $( $x: FromToNativeWasmType, )*
-                Rets: WasmTypeList,
-                RetsAsResult: IntoResult<Rets>,
-                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<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
-                }
-
-                #[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>
-                }
-
-            }
-
-            // 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 {
-                    /// 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>
-                }
-
-            }
-        };
-    }
-
-// 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/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..5faf704495
--- /dev/null
+++ b/lib/api/src/utils/macros/backend.rs
@@ -0,0 +1,175 @@
+/// 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,)*)]
+            #[allow(clippy::large_enum_variant)]
+            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..71da1165b3
--- /dev/null
+++ b/lib/api/src/utils/mem/access.rs
@@ -0,0 +1,368 @@
+use std::mem::{self, MaybeUninit};
+use std::slice;
+
+use crate::{
+    MemoryAccessError,
+    utils::mem::{WasmRef, WasmSlice},
+};
+
+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
+            && *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
+            && *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..dcb089297d 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::{
+    AsStoreRef, FromToNativeWasmType, MemoryAccessError, NativeWasmTypeInto, WasmRef, WasmSlice,
+    access::WasmRefAccess, view::MemoryView,
+};
 
 /// 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 80%
rename from lib/api/src/native_type.rs
rename to lib/api/src/utils/native/convert.rs
index 5879ff3da7..05c4a1b977 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::{
+    ExternRef, Function, TypedFunction,
+    vm::{VMExternRef, VMFuncRef},
+};
 
-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;
 
@@ -51,7 +52,7 @@ impl NativeWasmTypeInto for i32 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i32
+        unsafe { raw.i32 }
     }
 }
 
@@ -73,7 +74,7 @@ impl NativeWasmTypeInto for u32 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i32 as _
+        unsafe { raw.i32 as _ }
     }
 }
 
@@ -95,7 +96,7 @@ impl NativeWasmTypeInto for i64 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i64
+        unsafe { raw.i64 }
     }
 }
 
@@ -117,7 +118,7 @@ impl NativeWasmTypeInto for u64 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i64 as _
+        unsafe { raw.i64 as _ }
     }
 }
 
@@ -139,7 +140,7 @@ impl NativeWasmTypeInto for f32 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.f32
+        unsafe { raw.f32 }
     }
 }
 
@@ -161,7 +162,7 @@ impl NativeWasmTypeInto for f64 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.f64
+        unsafe { raw.f64 }
     }
 }
 
@@ -183,7 +184,7 @@ impl NativeWasmTypeInto for u128 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.u128
+        unsafe { raw.u128 }
     }
 }
 
@@ -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(_) => unsafe {
+                wasmer_vm::VMExternRef::from_raw(RawValue { externref: abi }).map(VMExternRef::Sys)
+            },
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsafe {
+                crate::backend::wamr::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Wamr)
+            },
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsafe {
+                crate::backend::wasmi::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Wasmi)
+            },
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsafe {
+                crate::backend::v8::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::V8)
+            },
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsafe {
+                crate::backend::js::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Js)
+            },
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsafe {
+                crate::backend::jsc::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Jsc)
+            },
+        }
+        .map(|e| unsafe { 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(_) => unsafe {
+                wasmer_vm::VMExternRef::from_raw(raw).map(VMExternRef::Sys)
+            },
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsafe {
+                crate::backend::wamr::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wamr)
+            },
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsafe {
+                crate::backend::wasmi::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wasmi)
+            },
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsafe {
+                crate::backend::v8::vm::VMExternRef::from_raw(raw).map(VMExternRef::V8)
+            },
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsafe {
+                crate::backend::js::vm::VMExternRef::from_raw(raw).map(VMExternRef::Js)
+            },
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsafe {
+                crate::backend::jsc::vm::VMExternRef::from_raw(raw).map(VMExternRef::Jsc)
+            },
+        }
+        .map(|e| unsafe { 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(_) => unsafe {
+                wasmer_vm::VMFuncRef::from_raw(RawValue { funcref: abi }).map(VMFuncRef::Sys)
+            },
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsafe {
+                crate::backend::wamr::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Wamr)
+            },
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsafe {
+                crate::backend::wasmi::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Wasmi)
+            },
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsafe {
+                crate::backend::v8::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::V8)
+            },
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsafe {
+                crate::backend::js::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Js)
+            },
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsafe {
+                crate::backend::jsc::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Jsc)
+            },
+        }
+        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
     }
 
     #[inline]
@@ -250,7 +338,33 @@ 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(_) => unsafe {
+                wasmer_vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Sys)
+            },
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => unsafe {
+                crate::backend::wamr::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wamr)
+            },
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => unsafe {
+                crate::backend::wasmi::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wasmi)
+            },
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => unsafe {
+                crate::backend::v8::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::V8)
+            },
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => unsafe {
+                crate::backend::js::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Js)
+            },
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => unsafe {
+                crate::backend::jsc::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Jsc)
+            },
+        }
+        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
     }
 }
 
@@ -365,7 +479,7 @@ unsafe impl FromToNativeWasmType for Option<ExternRef> {
         n
     }
     fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.as_ref().map_or(true, |e| e.is_from_store(store))
+        self.as_ref().is_none_or(|e| e.is_from_store(store))
     }
 }
 
@@ -379,7 +493,7 @@ unsafe impl FromToNativeWasmType for Option<Function> {
         n
     }
     fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.as_ref().map_or(true, |f| f.is_from_store(store))
+        self.as_ref().is_none_or(|f| f.is_from_store(store))
     }
 }
 
@@ -648,14 +762,18 @@ macro_rules! impl_wasmtypelist {
                 // Build the tuple.
                 (
                     $(
-                        FromToNativeWasmType::from_native(NativeWasmTypeInto::from_raw(_store, $x))
+                        {
+                            let native = unsafe { NativeWasmTypeInto::from_raw(_store, $x) };
+                            FromToNativeWasmType::from_native(native)
+                        }
                     ),*
                 )
             }
 
             #[allow(clippy::missing_safety_doc)]
             unsafe fn from_slice(store: &mut impl AsStoreMut, slice: &[RawValue]) -> Result<Self, TryFromSliceError> {
-                Ok(Self::from_array(store, slice.try_into()?))
+                let array = slice.try_into()?;
+                Ok(unsafe { Self::from_array(store, array) })
             }
 
             #[allow(unused_mut)]
@@ -688,7 +806,10 @@ macro_rules! impl_wasmtypelist {
 
                 (
                     $(
-                        FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(_store, $x))
+                        {
+                            let native = unsafe { NativeWasmTypeInto::from_abi(_store, $x) };
+                            FromToNativeWasmType::from_native(native)
+                        }
                     ),*
                 )
             }
@@ -714,7 +835,9 @@ macro_rules! impl_wasmtypelist {
 
                 let mut _n = 0;
                 $(
-                    *_ptr.add(_n).cast() = $x;
+                    unsafe {
+                        *_ptr.add(_n).cast() = $x;
+                    }
                     _n += 1;
                 )*
             }
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..546858309e
--- /dev/null
+++ b/lib/api/src/utils/native/typed_func.rs
@@ -0,0 +1,186 @@
+//! 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();
+//! ```
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
+use crate::{
+    AsStoreMut, BackendStore, FromToNativeWasmType, Function, NativeWasmTypeInto, RuntimeError,
+    WasmTypeList, store::AsStoreRef,
+};
+use std::future::Future;
+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>]),*),
+
+                }
+            }
+
+            /// Call the typed func asynchronously.
+            #[cfg(feature = "experimental-async")]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_async(
+                &self,
+                store: &impl AsStoreAsync,
+                $( $x: $x, )*
+            ) -> impl Future<Output = Result<Rets, RuntimeError>> + Sized + 'static
+            where
+                $( $x: FromToNativeWasmType + 'static, )*
+            {
+                $(
+                    let [<p_ $x>] = $x;
+                )*
+                let store = store.store();
+                let func = self.func.clone();
+                async move {
+                    let read_lock = store.read_lock().await;
+                    match read_lock.as_store_ref().inner.store {
+                        #[cfg(feature = "sys")]
+                        BackendStore::Sys(_) => {
+                            drop(read_lock);
+                            Self::call_async_sys(func, store, $([<p_ $x>]),*).await
+                        }
+                        #[cfg(feature = "wamr")]
+                        BackendStore::Wamr(_) => async_backend_error(),
+                        #[cfg(feature = "wasmi")]
+                        BackendStore::Wasmi(_) => async_backend_error(),
+                        #[cfg(feature = "v8")]
+                        BackendStore::V8(_) => async_backend_error(),
+                        #[cfg(feature = "js")]
+                        BackendStore::Js(_) => async_backend_error(),
+                        #[cfg(feature = "jsc")]
+                        BackendStore::Jsc(_) => async_backend_error(),
+                    }
+                }
+            }
+
+            #[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
+);
+
+fn async_backend_error<Rets>() -> Result<Rets, RuntimeError> {
+    Err(RuntimeError::new(
+        "async calls are only supported with the `sys` backend",
+    ))
+}
diff --git a/lib/api/src/module_info_polyfill.rs b/lib/api/src/utils/polyfill.rs
similarity index 83%
rename from lib/api/src/module_info_polyfill.rs
rename to lib/api/src/utils/polyfill.rs
index 43c3aa3181..b55df9c2ef 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,
+    GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, Imports,
+    MemorySectionReader, 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,
                     )?;
                 }
@@ -320,7 +373,7 @@ pub fn wpreftype_to_type(ty: wasmparser::RefType) -> WasmResult<Type> {
     } else if ty.is_func_ref() {
         Ok(Type::FuncRef)
     } else {
-        Err(format!("Unsupported ref type: {:?}", ty))
+        Err(format!("Unsupported ref type: {ty:?}"))
     }
 }
 
@@ -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,14 +420,18 @@ 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())?;
 
     for entry in imports {
         let import = entry.map_err(transform_err)?;
+        let Imports::Single(_index, import) = import else {
+            return Err("non-Single section Imports not implemented yet".to_string());
+        };
+
         let module_name = import.module;
         let field_name = import.name;
 
@@ -386,14 +443,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,13 +480,14 @@ 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,
                 )?;
             }
+            TypeRef::FuncExact(_) => unimplemented!("custom-descriptors not implemented yet"),
         }
     }
     Ok(())
@@ -461,8 +520,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 +541,7 @@ pub fn parse_memory_section(
             memory64,
             initial,
             maximum,
+            ..
         } = entry.map_err(transform_err)?;
         if memory64 {
             unimplemented!("64bit memory not implemented yet");
@@ -507,6 +567,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 +579,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,8 +625,9 @@ 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)?,
+            ExternalKind::FuncExact => {
+                return Err("custom-descriptors not implemented yet".to_string());
             }
         }
     }
@@ -564,8 +641,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 +672,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..ea80315092
--- /dev/null
+++ b/lib/api/src/vm/impls.rs
@@ -0,0 +1,65 @@
+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 {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.into_raw(),
+
+            _ => unimplemented!("VMExceptionRef::into_raw is only implemented for the sys backend"),
+        }
+    }
+}
diff --git a/lib/api/src/vm/mod.rs b/lib/api/src/vm/mod.rs
new file mode 100644
index 0000000000..131f848fbb
--- /dev/null
+++ b/lib/api/src/vm/mod.rs
@@ -0,0 +1,447 @@
+//! 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!(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..f59611a8c8 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>(&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>(&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>(&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: cfg!(feature = "wamr"),
         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/jspi_async.rs b/lib/api/tests/jspi_async.rs
new file mode 100644
index 0000000000..e4b1454240
--- /dev/null
+++ b/lib/api/tests/jspi_async.rs
@@ -0,0 +1,305 @@
+#![cfg(feature = "experimental-async")]
+
+use std::{cell::RefCell, sync::OnceLock};
+
+use anyhow::Result;
+use futures::future;
+use wasmer::{
+    AsyncFunctionEnvMut, Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Module,
+    Store, StoreAsync, Type, TypedFunction, Value, imports,
+};
+use wasmer_vm::TrapCode;
+
+#[derive(Default)]
+struct DeltaState {
+    deltas: Vec<f64>,
+    index: usize,
+}
+
+impl DeltaState {
+    fn next(&mut self) -> f64 {
+        let value = self.deltas.get(self.index).copied().unwrap_or(0.0);
+        self.index += 1;
+        value
+    }
+}
+
+fn jspi_module() -> &'static [u8] {
+    static BYTES: OnceLock<Vec<u8>> = OnceLock::new();
+    const JSPI_WAT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/examples/jspi.wat");
+    BYTES.get_or_init(|| wat::parse_file(JSPI_WAT).expect("valid example module"))
+}
+
+#[test]
+fn async_state_updates_follow_jspi_example() -> Result<()> {
+    let wasm = jspi_module();
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm)?;
+
+    let init_state = Function::new_async(
+        &mut store,
+        FunctionType::new(vec![], vec![Type::F64]),
+        |_values| async move {
+            // Note: future::ready doesn't actually suspend. It's important
+            // to note that, while we're in an async import here, it's
+            // impossible to suspend during module instantiation, which is
+            // where this import is called.
+            // To see this in action, uncomment the following line:
+            // tokio::task::yield_now().await;
+            future::ready(()).await;
+            Ok(vec![Value::F64(1.0)])
+        },
+    );
+
+    let delta_env = FunctionEnv::new(
+        &mut store,
+        DeltaState {
+            deltas: vec![0.5, -1.0, 2.5],
+            index: 0,
+        },
+    );
+    let compute_delta = Function::new_with_env_async(
+        &mut store,
+        &delta_env,
+        FunctionType::new(vec![], vec![Type::F64]),
+        |env: AsyncFunctionEnvMut<DeltaState>, _values| async move {
+            // Note: holding a lock across an await point prevents
+            // other coroutines from progressing, so it's a good
+            // idea to drop the lock before awaiting.
+            let delta = {
+                let mut env_write = env.write().await;
+                env_write.data_mut().next()
+            };
+            // We can, however, actually suspend whenever
+            // `Function::call_async` is used to call WASM functions.
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+            Ok(vec![Value::F64(delta)])
+        },
+    );
+
+    let import_object = imports! {
+        "js" => {
+            "init_state" => init_state,
+            "compute_delta" => compute_delta,
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+    let get_state = instance.exports.get_function("get_state")?;
+    let update_state = instance.exports.get_function("update_state")?;
+
+    fn as_f64(values: &[Value]) -> f64 {
+        match &values[0] {
+            Value::F64(v) => *v,
+            other => panic!("expected f64 value, got {other:?}"),
+        }
+    }
+
+    assert_eq!(as_f64(&get_state.call(&mut store, &[])?), 1.0);
+
+    let step = |store: &StoreAsync, func: &wasmer::Function| -> Result<f64> {
+        let result = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+            .block_on(func.call_async(store, vec![]))?;
+        Ok(as_f64(&result))
+    };
+
+    let store_async = store.into_async();
+
+    assert_eq!(step(&store_async, update_state)?, 1.5);
+    assert_eq!(step(&store_async, update_state)?, 0.5);
+    assert_eq!(step(&store_async, update_state)?, 3.0);
+
+    Ok(())
+}
+
+#[test]
+fn typed_async_host_and_calls_work() -> Result<()> {
+    let wasm = wat::parse_str(
+        r#"
+        (module
+          (import "host" "async_add" (func $async_add (param i32 i32) (result i32)))
+          (import "host" "async_double" (func $async_double (param i32) (result i32)))
+          (func (export "compute") (param i32) (result i32)
+            local.get 0
+            i32.const 10
+            call $async_add
+            local.get 0
+            call $async_double
+            i32.add))
+        "#,
+    )?;
+
+    #[derive(Clone, Copy)]
+    struct AddBias {
+        bias: i32,
+    }
+
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm)?;
+
+    let add_env = FunctionEnv::new(&mut store, AddBias { bias: 5 });
+    let async_add = Function::new_typed_with_env_async(
+        &mut store,
+        &add_env,
+        async move |env: AsyncFunctionEnvMut<AddBias>, a: i32, b: i32| {
+            let env_read = env.read().await;
+            let bias = env_read.data().bias;
+            tokio::task::yield_now().await;
+            a + b + bias
+        },
+    );
+    let async_double = Function::new_typed_async(&mut store, async move |value: i32| {
+        tokio::task::yield_now().await;
+        value * 2
+    });
+
+    let import_object = imports! {
+        "host" => {
+            "async_add" => async_add,
+            "async_double" => async_double,
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+    let compute: TypedFunction<i32, i32> =
+        instance.exports.get_typed_function(&store, "compute")?;
+
+    let store_async = store.into_async();
+
+    let result = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(compute.call_async(&store_async, 4))?;
+    assert_eq!(result, 27);
+
+    Ok(())
+}
+
+#[test]
+fn cannot_yield_when_not_in_async_context() -> Result<()> {
+    const WAT: &str = r#"
+    (module
+        (import "env" "yield_now" (func $yield_now))
+        (func (export "yield_outside")
+            call $yield_now
+        )
+    )
+    "#;
+    let wasm = wat::parse_str(WAT).expect("valid WAT module");
+
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm)?;
+
+    let yield_now = Function::new_async(
+        &mut store,
+        FunctionType::new(vec![], vec![]),
+        |_values| async move {
+            // Attempting to yield when not in an async context should trap.
+            tokio::task::yield_now().await;
+            Ok(vec![])
+        },
+    );
+
+    let import_object = imports! {
+        "env" => {
+            "yield_now" => yield_now,
+        }
+    };
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+    let yield_outside = instance.exports.get_function("yield_outside")?;
+
+    let trap = yield_outside
+        .call(&mut store, &[])
+        .expect_err("expected trap calling yield outside async context");
+
+    // TODO: wasm trace generation appears to be broken?
+    // assert!(!trap.trace().is_empty(), "should have a stack trace");
+    let trap_code = trap.to_trap().expect("expected trap code");
+    assert_eq!(
+        trap_code,
+        TrapCode::YieldOutsideAsyncContext,
+        "expected YieldOutsideAsyncContext trap code"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn nested_async_in_sync() -> Result<()> {
+    const WAT: &str = r#"
+    (module
+        (import "env" "sync" (func $sync (result i32)))
+        (import "env" "async" (func $async (result i32)))
+        (func (export "entry") (result i32)
+            call $sync
+        )
+        (func (export "inner_async") (result i32)
+            call $async
+        )
+    )
+    "#;
+    let wasm = wat::parse_str(WAT).expect("valid WAT module");
+
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm)?;
+
+    struct Env {
+        inner_async: RefCell<Option<wasmer::TypedFunction<(), i32>>>,
+    }
+    let env = FunctionEnv::new(
+        &mut store,
+        Env {
+            inner_async: RefCell::new(None),
+        },
+    );
+
+    let sync = Function::new_typed_with_env(&mut store, &env, |mut env: FunctionEnvMut<Env>| {
+        let (env, mut store) = env.data_and_store_mut();
+        env.inner_async
+            .borrow()
+            .as_ref()
+            .expect("inner_async function to be set")
+            .call(&mut store)
+            .expect("inner async call to succeed")
+    });
+
+    let async_ = Function::new_typed_async(&mut store, async || {
+        tokio::task::yield_now().await;
+        42
+    });
+
+    let imports = imports! {
+        "env" => {
+            "sync" => sync,
+            "async" => async_,
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &imports)?;
+
+    let inner_async = instance
+        .exports
+        .get_typed_function::<(), i32>(&store, "inner_async")
+        .unwrap();
+    env.as_mut(&mut store)
+        .inner_async
+        .borrow_mut()
+        .replace(inner_async);
+
+    let entry = instance
+        .exports
+        .get_typed_function::<(), i32>(&store, "entry")?;
+    let result = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(entry.call_async(&store.into_async()))?;
+
+    assert_eq!(result, 42);
+
+    Ok(())
+}
diff --git a/lib/api/tests/memory.rs b/lib/api/tests/memory.rs
index bf5f6ecb04..335bb32010 100644
--- a/lib/api/tests/memory.rs
+++ b/lib/api/tests/memory.rs
@@ -1,11 +1,17 @@
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
-
-use wasmer::{imports, Instance, Memory, MemoryLocation, MemoryType, Module, Store};
+use wasmer::{Instance, Memory, MemoryLocation, MemoryType, Module, Store, imports};
 
 #[test]
+#[allow(unused_attributes)]
+#[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
@@ -36,9 +42,11 @@ fn test_shared_memory_atomics_notify_send() {
 
     // Test basic notify.
     let mem2 = mem.clone();
-    std::thread::spawn(move || loop {
-        if mem2.notify(MemoryLocation::new_32(10), 1).unwrap() > 0 {
-            break;
+    std::thread::spawn(move || {
+        loop {
+            if mem2.notify(MemoryLocation::new_32(10), 1).unwrap() > 0 {
+                break;
+            }
         }
     });
 
@@ -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 = wasmer::WasmSlice::<u64>::new(&view, 1, 10).unwrap();
+    let access = slice.access();
+
+    assert!(matches!(
+        access.err(),
+        Some(wasmer::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..022748d186 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,36 +194,36 @@ 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);
-                assert_eq!(p, u64::max_value());
+                println!("host_func1: Found number {p}");
+                assert_eq!(p, u64::MAX);
             }),
             "host_func2" => Function::new_typed(&mut store, |p: u32| {
-                println!("host_func2: Found number {}", p);
-                assert_eq!(p, u32::max_value());
+                println!("host_func2: Found number {p}");
+                assert_eq!(p, u32::MAX);
             }),
             "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);
-                assert_eq!(p, u16::max_value());
+                println!("host_func6: Found number {p}");
+                assert_eq!(p, u16::MAX);
             }),
             "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);
-                assert_eq!(p, u8::max_value());
+                println!("host_func8: Found number {p}");
+                assert_eq!(p, u8::MAX);
             }),
         }
     };
@@ -277,6 +275,10 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
 }
 
 #[universal_test]
+#[allow(unused_attributes)]
+#[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/module_compilation_progress.rs b/lib/api/tests/module_compilation_progress.rs
new file mode 100644
index 0000000000..ce53ae9316
--- /dev/null
+++ b/lib/api/tests/module_compilation_progress.rs
@@ -0,0 +1,113 @@
+#![cfg(any(feature = "cranelift", feature = "llvm", feature = "singlepass"))]
+
+use std::sync::{Arc, Mutex};
+
+use wasmer::sys::NativeEngineExt as _;
+use wasmer::{CompileError, Engine};
+use wasmer_types::{CompilationProgress, UserAbort};
+
+#[cfg(feature = "singlepass")]
+#[test]
+fn test_module_compilation_progress_singlepass() {
+    let compiler = wasmer::sys::Singlepass::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_progress(engine);
+}
+
+#[cfg(feature = "singlepass")]
+#[test]
+fn test_module_compilation_abort_singlepass() {
+    let compiler = wasmer::sys::Cranelift::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_abort(engine);
+}
+
+#[cfg(feature = "cranelift")]
+#[test]
+fn test_module_compilation_progress_cranelift() {
+    let compiler = wasmer::sys::Cranelift::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_progress(engine);
+}
+
+#[cfg(feature = "cranelift")]
+#[test]
+fn test_module_compilation_abort_cranelift() {
+    let compiler = wasmer::sys::Cranelift::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_abort(engine);
+}
+
+#[cfg(feature = "llvm")]
+#[test]
+fn test_module_compilation_progress_llvm() {
+    let compiler = wasmer::sys::LLVM::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_progress(engine);
+}
+
+#[cfg(feature = "llvm")]
+#[test]
+fn test_module_compilation_abort_llvm() {
+    let compiler = wasmer::sys::LLVM::default();
+    let engine: wasmer::Engine = wasmer::sys::EngineBuilder::new(compiler).engine().into();
+    test_module_compilation_abort(engine);
+}
+
+const SIMPLE_WAT: &str = r#"(module
+  (import "env" "div" (func $div (param i32 i32) (result i32)))
+  (func (export "add") (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    i32.add)
+  (func (export "sub") (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    i32.sub)
+) "#;
+
+fn test_module_compilation_progress(engine: Engine) {
+    let items = Arc::new(Mutex::new(Vec::<CompilationProgress>::new()));
+
+    let cb = wasmer_types::CompilationProgressCallback::new({
+        let items = items.clone();
+        move |p| {
+            items.lock().unwrap().push(p);
+            Ok(())
+        }
+    });
+    let _module = engine
+        .new_module_with_progress(SIMPLE_WAT.as_bytes(), cb)
+        .unwrap();
+
+    let last = items
+        .lock()
+        .unwrap()
+        .last()
+        .expect("expected at least one progress item")
+        .clone();
+
+    // 4 total steps:
+    // - 2 functions
+    // - 1 trampoline for exports (both share same signature)
+    // - 1 trampoline for imported function
+    assert_eq!(last.phase_step_count(), Some(4));
+    assert_eq!(last.phase_step(), Some(4));
+}
+
+fn test_module_compilation_abort(engine: Engine) {
+    let reason = "my reason";
+    let cb = wasmer_types::CompilationProgressCallback::new(move |_p| Err(UserAbort::new(reason)));
+    let err = engine
+        .new_module_with_progress(SIMPLE_WAT.as_bytes(), cb)
+        .expect_err("should fail");
+
+    match err {
+        CompileError::Aborted(e) => {
+            assert_eq!(e.reason(), reason)
+        }
+        other => {
+            panic!("expected CompileError::Aborted, got {:?}", other);
+        }
+    }
+}
diff --git a/lib/api/tests/reference_types.rs b/lib/api/tests/reference_types.rs
index b7138543f2..3350873bfe 100644
--- a/lib/api/tests/reference_types.rs
+++ b/lib/api/tests/reference_types.rs
@@ -3,8 +3,8 @@ pub mod reference_types {
 
     use anyhow::Result;
     use macro_wasmer_universal_test::universal_test;
-    use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::Arc;
+    use std::sync::atomic::{AtomicBool, Ordering};
     #[cfg(feature = "js")]
     use wasm_bindgen_test::*;
     use wasmer::*;
@@ -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..4e542bf3b1
--- /dev/null
+++ b/lib/api/tests/rt.rs
@@ -0,0 +1,73 @@
+#[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 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/simple_greenthread.rs b/lib/api/tests/simple_greenthread.rs
new file mode 100644
index 0000000000..61f8e512be
--- /dev/null
+++ b/lib/api/tests/simple_greenthread.rs
@@ -0,0 +1,275 @@
+#![cfg(feature = "experimental-async")]
+
+use std::collections::BTreeMap;
+use std::sync::atomic::AtomicU32;
+use std::sync::{Arc, RwLock};
+
+use anyhow::Result;
+use futures::task::LocalSpawnExt;
+use futures::{FutureExt, channel::oneshot};
+use wasmer::{
+    AsyncFunctionEnvMut, Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Memory,
+    Module, RuntimeError, Store, Type, Value, imports,
+};
+
+struct GreenEnv {
+    logs: Vec<String>,
+    memory: Option<Memory>,
+    greenthreads: Arc<RwLock<BTreeMap<u32, Greenthread>>>,
+    current_greenthread_id: Arc<RwLock<u32>>,
+    next_free_id: AtomicU32,
+    entrypoint: Option<Function>,
+    spawner: Option<futures::executor::LocalSpawner>,
+}
+
+// Required for carrying the spawner around. Safe because we don't do threads.
+// It worked before with a thread-local! spawner, so this is equivalent.
+// The thread-local version does not work with multiple tests
+unsafe impl Send for GreenEnv {}
+unsafe impl Sync for GreenEnv {}
+
+impl GreenEnv {
+    fn new() -> Self {
+        Self {
+            logs: Vec::new(),
+            memory: None,
+            greenthreads: Arc::new(RwLock::new(BTreeMap::new())),
+            current_greenthread_id: Arc::new(RwLock::new(0)),
+            next_free_id: AtomicU32::new(1),
+            entrypoint: None,
+            spawner: None,
+        }
+    }
+}
+
+struct Greenthread {
+    entrypoint: Option<u32>,
+    resumer: Option<oneshot::Sender<()>>,
+}
+
+impl Clone for Greenthread {
+    fn clone(&self) -> Self {
+        if self.resumer.is_some() {
+            panic!("Cannot clone a greenthread with a resumer");
+        }
+        Self {
+            entrypoint: self.entrypoint,
+            resumer: None,
+        }
+    }
+}
+
+async fn greenthread_new(
+    env: AsyncFunctionEnvMut<GreenEnv>,
+    entrypoint_data: u32,
+) -> core::result::Result<u32, RuntimeError> {
+    let async_store = env.as_store_async();
+    let mut env_write = env.write().await;
+    let data = env_write.data_mut();
+    let new_greenthread_id = data
+        .next_free_id
+        .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+
+    let function = data.entrypoint.clone().expect("entrypoint set");
+    let (sender, receiver) = oneshot::channel::<()>();
+
+    let new_greenthread = Greenthread {
+        entrypoint: Some(entrypoint_data),
+        resumer: Some(sender),
+    };
+
+    data.greenthreads
+        .write()
+        .unwrap()
+        .insert(new_greenthread_id, new_greenthread);
+
+    let spawner = data.spawner.as_ref().expect("spawner set").clone();
+    spawner
+        .spawn_local(async move {
+            receiver.await.unwrap();
+            let resumer = function
+                .call_async(&async_store, vec![Value::I32(entrypoint_data as i32)])
+                .await;
+            panic!("Greenthread function returned {:?}", resumer);
+        })
+        .unwrap();
+
+    Ok(new_greenthread_id)
+}
+
+async fn greenthread_switch(env: AsyncFunctionEnvMut<GreenEnv>, next_greenthread_id: u32) {
+    let (receiver, current_id_arc, current_greenthread_id) = {
+        let mut write_lock = env.write().await;
+        let data = write_lock.data_mut();
+
+        let current_greenthread_id = {
+            let mut current = data.current_greenthread_id.write().unwrap();
+            let old = *current;
+            *current = next_greenthread_id;
+            old
+        };
+
+        if current_greenthread_id == next_greenthread_id {
+            panic!("Switching to self is not allowed");
+        }
+
+        let (sender, receiver) = oneshot::channel::<()>();
+
+        {
+            let mut greenthreads = data.greenthreads.write().unwrap();
+            let this_one = greenthreads.get_mut(&current_greenthread_id).unwrap();
+            if this_one.resumer.is_some() {
+                panic!("Switching from a greenthread that is already switched out");
+            }
+            this_one.resumer = Some(sender);
+        }
+
+        {
+            let mut greenthreads = data.greenthreads.write().unwrap();
+            let next_one = greenthreads.get_mut(&next_greenthread_id).unwrap();
+            let Some(resumer) = next_one.resumer.take() else {
+                panic!("Switching to greenthread that has no resumer");
+            };
+            resumer.send(()).unwrap();
+        }
+        let current_id_arc = data.current_greenthread_id.clone();
+
+        (receiver, current_id_arc, current_greenthread_id)
+    };
+
+    let _ = receiver.map(|_| ()).await;
+
+    *current_id_arc.write().unwrap() = current_greenthread_id;
+}
+
+fn run_greenthread_test(wat: &[u8]) -> Result<Vec<String>> {
+    let mut store = Store::default();
+    let module = Module::new(&store.engine(), wat)?;
+
+    let env = FunctionEnv::new(&mut store, GreenEnv::new());
+
+    // log(ptr, len)
+    let log_fn = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(vec![Type::I32, Type::I32], vec![]),
+        |mut env: FunctionEnvMut<GreenEnv>, params: &[Value]| {
+            let ptr = params[0].unwrap_i32() as u32;
+            let len = params[1].unwrap_i32() as u32;
+            let (data, storemut) = env.data_and_store_mut();
+            let memory = data.memory.as_ref().expect("memory set");
+            let view = memory.view(&storemut);
+            let mut bytes = Vec::with_capacity(len as usize);
+            for i in ptr..ptr + len {
+                bytes.push(view.read_u8(i as u64).expect("in bounds"));
+            }
+            let s = String::from_utf8_lossy(&bytes).to_string();
+            data.logs.push(s.trim_matches('\0').to_string());
+            Ok(vec![])
+        },
+    );
+
+    let greenthread_new = Function::new_typed_with_env_async(&mut store, &env, greenthread_new);
+
+    let greenthread_switch =
+        Function::new_typed_with_env_async(&mut store, &env, greenthread_switch);
+
+    let import_object = imports! {
+        "test" => {
+            "log" => log_fn,
+            "greenthread_new" => greenthread_new,
+            "greenthread_switch" => greenthread_switch,
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let entrypoint = instance.exports.get_function("entrypoint")?.clone();
+    env.as_mut(&mut store).entrypoint = Some(entrypoint);
+
+    let memory = instance.exports.get_memory("memory")?.clone();
+    env.as_mut(&mut store).memory = Some(memory);
+
+    let main_fn = instance.exports.get_function("_main")?;
+
+    let main_greenthread = Greenthread {
+        entrypoint: None,
+        resumer: None,
+    };
+
+    env.as_mut(&mut store)
+        .greenthreads
+        .write()
+        .unwrap()
+        .insert(0, main_greenthread);
+
+    let mut localpool = futures::executor::LocalPool::new();
+    let local_spawner = localpool.spawner();
+    env.as_mut(&mut store).spawner = Some(local_spawner);
+
+    let store_async = store.into_async();
+
+    localpool
+        .run_until(main_fn.call_async(&store_async, vec![]))
+        .unwrap();
+
+    // If there are no more clones of it, StoreAsync can also be
+    // turned back into a store. We need to drop the local pool
+    // first to drop the futures and their references to the store.
+    drop(localpool);
+
+    let store = store_async.into_store().ok().unwrap();
+    Ok(env.as_ref(&store).logs.clone())
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn green_threads_switch_and_log_in_expected_order() -> Result<()> {
+    let logs = run_greenthread_test(include_bytes!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../tests/examples/simple-greenthread.wat"
+    )))?;
+
+    // Expected logs
+    let expected = [
+        "[gr1] main  -> test1",
+        "[gr2] test1 -> test2",
+        "[gr1] test1 <- test2",
+        "[gr2] test1 -> test2",
+        "[gr1] test1 <- test2",
+        "[main] main <- test1",
+    ];
+
+    assert_eq!(logs.len(), expected.len(),);
+    for (i, exp) in expected.iter().enumerate() {
+        assert_eq!(logs[i], *exp, "Log entry mismatch at index {i}: {:?}", logs);
+    }
+
+    Ok(())
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn green_threads_switch_main_crashed() -> Result<()> {
+    let logs = run_greenthread_test(include_bytes!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../tests/examples/simple-greenthread2.wat"
+    )))?;
+
+    // Expected logs
+    let expected = [
+        "[main] switching to side",
+        "[side] switching to main",
+        "[main] switching to side",
+        "[side] switching to main",
+        "[main] returned",
+    ];
+
+    eprintln!("logs: {:?}", logs);
+    assert_eq!(logs.len(), expected.len());
+    for (i, exp) in expected.iter().enumerate() {
+        assert_eq!(logs[i], *exp, "Log entry mismatch at index {i}: {:?}", logs);
+    }
+
+    Ok(())
+}
diff --git a/lib/api/tests/typed_functions.rs b/lib/api/tests/typed_functions.rs
new file mode 100644
index 0000000000..d746a1a95f
--- /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(&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(&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..75e9129fac 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.700.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,53 @@ 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.700.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"] }
-futures = "0.3"
-tracing = "0.1"
-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"
+
+anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_path_to_error.workspace = true
+time = { workspace = true, features = ["formatting", "parsing"] }
+tokio.workspace = true
+url = { workspace = true, features = ["serde"] }
+futures.workspace = true
+tracing = { workspace = true, default-features = true }
+cynic = { workspace = true, features = ["http-reqwest"] }
+pin-project-lite.workspace = true
+harsh.workspace = true
+merge-streams.workspace = true
+
+# Subscriptions. 
+graphql-ws-client = { workspace = true, features = [
+	"tungstenite-0.28",
+	"client-cynic",
+], optional = true }
+tokio-tungstenite = { workspace = true, features = [
+	"rustls-tls-native-roots",
+], optional = true }
+async-tungstenite = { workspace = true, 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"] }
-uuid = { version = "1", features = ["v4"] }
+tokio = { workspace = true, features = ["macros", "rt"] }
+base64.workspace = true
+uuid = { workspace = true, 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..48085194cf 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!
@@ -45,7 +46,9 @@ type User implements Node & PackageOwner & Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  isPro: Boolean!
   avatar(size: Int = 80): String!
+  limitState: LimitState!
   isViewer: Boolean!
   hasUsablePassword: Boolean
   fullName: String!
@@ -59,19 +62,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]!
+  githubScopes: [String]! @deprecated(reason: "Please use github installations instead.")
+  githubRepositories: [GithubInstallationRepository]! @deprecated(reason: "Please use github installations instead.")
+  githubInstallationExists: Boolean! @deprecated(reason: "Please use github installations instead.")
+  githubInstallations: [GithubAppInstallation!]
+  currentUsage(
+    """List of app IDs. Usage gets filtered for the specific apps."""
+    appIds: [ID]
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): OwnerUsageSummary
 }
 
 """Setup for backwards compatibility with existing frontends."""
@@ -86,11 +108,11 @@ enum OwnerAction {
   PUBLISH_PACKAGE
 }
 
-"""An owner of a package."""
 interface Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  isPro: Boolean!
 }
 
 """
@@ -100,6 +122,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 +229,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 +245,14 @@ type Namespace implements Node & PackageOwner & Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  isPro: 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 +263,25 @@ 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!
+  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 +322,7 @@ type NamespaceCollaboratorInvite implements Node {
   closedAt: DateTime
 }
 
+"""An enumeration."""
 enum RegistryNamespaceMaintainerInviteRoleChoices {
   """Owner"""
   OWNER
@@ -297,6 +348,7 @@ type NamespaceCollaborator implements Node {
   invite: NamespaceCollaboratorInvite
 }
 
+"""An enumeration."""
 enum RegistryNamespaceMaintainerRoleChoices {
   """Owner"""
   OWNER
@@ -371,12 +423,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!
@@ -466,6 +518,7 @@ type PackageVersion implements Node & PackageReleaseInterface & PackageInstance
   javascriptlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
   pythonlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
   deployappversionSet(offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  packagerolloutSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageRolloutConnection!
   piritaManifest: JSONString
   piritaOffsets: JSONString
   piritaVolumes: JSONString
@@ -479,8 +532,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 +578,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 +619,7 @@ type PackageVersionEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum RegistryPackageVersionBindingsStateChoices {
   """Bindings are not detected"""
   NOT_PRESENT
@@ -580,6 +634,7 @@ enum RegistryPackageVersionBindingsStateChoices {
   GENERATED_AND_PRESENT
 }
 
+"""An enumeration."""
 enum RegistryPackageVersionNativeExecutablesStateChoices {
   """Native Executables are not detected"""
   NOT_PRESENT
@@ -635,7 +690,7 @@ type PackageWebc implements Node & PackageReleaseInterface & PackageInstance {
 type Command {
   command: String!
   packageVersion: PackageVersion!
-  module: PackageVersionModule!
+  module: PackageVersionModule
 }
 
 type PackageVersionModule {
@@ -880,7 +935,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,27 +974,40 @@ 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 @deprecated(reason: "This field is deprecated and return null always.")
+  rolloutSource: Rollout
   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!
+  isPro: Boolean!
   url: String!
   adminUrl: String!
   permalink: String!
@@ -948,15 +1018,31 @@ 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 @deprecated(reason: "Use rollouts instead")
+  rollouts(before: String, after: String, first: Int, last: Int): RolloutConnection
+  buildConfiguration: BuildConfiguration
+  sshServer: AppSshServer
+  mails: [AppMail]
+  kind: Kind
+  githubRepoConnection: GithubRepoConnection
 }
 
+"""An enumeration."""
 enum DeployAppVersionsSortBy {
   NEWEST
   OLDEST
@@ -993,18 +1079,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 +1117,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 +1172,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 +1216,7 @@ type UsageMetric {
   timestamp: DateTime!
 }
 
+"""An enumeration."""
 enum MetricType {
   cpu_time
   memory_time
@@ -1067,9 +1235,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 +1254,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 +1283,327 @@ 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
+  FAILED
+  QUEUED
+  TIMEOUT
+  INTERNAL_ERROR
+  CANCELLED
+}
+
+type BuildConfiguration implements Node {
+  setupDb: Boolean!
+  startCmd: String
+  buildCmd: String
+  installCmd: String
+  completionTimeInSeconds: Int!
+  kind: BuildKind
+
+  """The ID of the object"""
+  id: ID!
+  name: String
+  repo: String @deprecated(reason: "This field is deprecated and return null always.")
+  repoName: String @deprecated(reason: "This field is deprecated and return null always.")
+  repoNamespace: String @deprecated(reason: "This field is deprecated and return null always.")
+}
+
+type BuildKind implements Node {
+  setupDb: Boolean!
+  startCmd: String
+  buildCmd: String
+  installCmd: String
+  name: String!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+type RolloutConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [RolloutEdge]!
+}
+
+"""A Relay edge containing a `Rollout` and its cursor."""
+type RolloutEdge {
+  """The item at the end of the edge"""
+  node: Rollout
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Rollout implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deployappVersion: DeployAppVersion
+  buildCommand: String!
+  installCommand: String!
+  buildId: String
+  status: StatusEnum!
+  logUrl: String
+  buildConfiguration: BuildConfiguration
+  rolloutDetails: RolloutType
+}
+
+union RolloutType = GitHubRollout | ZipRollout | PackageRollout
+
+type GitHubRollout implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  externalId: String
+  rollout: Rollout!
+  branch: String
+  commitHash: String
+  prevCommitHash: String
+  commitMessage: String
+  authorEmail: String
+  authorName: String
+  authorLogin: String
+  repoUrl: String!
+  commitUrl: String
+}
+
+type ZipRollout implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  externalId: String
+  rollout: Rollout
+  zipFileUrl: String!
+  zipFileHash: String
+}
+
+type PackageRollout implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  externalId: String
+  rollout: Rollout!
+  sourcePackageVersion: PackageVersion
+  sourcePackageRelease: PackageWebc
+}
+
+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 | MCPServerAppKind
+
+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 MCPServerAppKind {
+  url: String!
+  transport: MCPServerTransportEnum
+}
+
+"""An enumeration."""
+enum MCPServerTransportEnum {
+  STDIO
+  STREAMABLE_HTTP
+  SSE
+}
+
 type LogConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -1125,6 +1621,7 @@ type LogEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum LogStream {
   STDOUT
   STDERR
@@ -1136,8 +1633,9 @@ type AppVersionVolume {
   name: String!
   s3Url: String!
   mountPaths: [AppVersionVolumeMountPath]!
-  size: Int
+  size: BigInt
   usedSize: BigInt
+  explorerUrl: String
 }
 
 type AppVersionVolumeMountPath {
@@ -1145,6 +1643,26 @@ type AppVersionVolumeMountPath {
   subpath: String
 }
 
+type PackageRolloutConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageRolloutEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageRollout` and its cursor."""
+type PackageRolloutEdge {
+  """The item at the end of the edge"""
+  node: PackageRollout
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
 type PackageDistribution {
   """
   Download URL of the tar.gz file.
@@ -1271,8 +1789,17 @@ type WebcImageEdge {
   cursor: String!
 }
 
-type AppTemplateConnection {
-  """Pagination data for this connection."""
+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!
 
   """Contains the nodes in this connection."""
@@ -1299,6 +1826,8 @@ type AppTemplate implements Node {
   description: String!
   demoUrl: String!
   repoUrl: String!
+  rootDir: String
+  branch: String
   category: AppTemplateCategory!
   isPublic: Boolean!
   createdAt: DateTime!
@@ -1307,7 +1836,11 @@ type AppTemplate implements Node {
   useCases: JSONString!
   repoLicense: String!
   usingPackage: Package
+  canDeployWithoutRepo: Boolean!
+  completionTimeInSeconds: Int!
+  highlighted: Boolean!
   defaultImage: String
+  defaultRepositoryCloneName: String
   framework: String!
   templateFramework: TemplateFramework
   language: String!
@@ -1343,15 +1876,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 +1962,7 @@ type PackageCollaborator implements Node {
   invite: PackageCollaboratorInvite
 }
 
+"""An enumeration."""
 enum RegistryPackageMaintainerRoleChoices {
   """Owner"""
   OWNER
@@ -1468,6 +1993,7 @@ type PackageCollaboratorInvite implements Node {
   closedAt: DateTime
 }
 
+"""An enumeration."""
 enum RegistryPackageMaintainerInviteRoleChoices {
   """Owner"""
   OWNER
@@ -1563,6 +2089,7 @@ type DeployAppEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum DeployAppsSortBy {
   NEWEST
   OLDEST
@@ -1768,6 +2295,7 @@ type CAARecord implements Node & DNSRecordInterface {
   domain: DNSDomain!
 }
 
+"""An enumeration."""
 enum DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
   """issue"""
   ISSUE
@@ -1909,6 +2437,7 @@ type SSHFPRecord implements Node & DNSRecordInterface {
   domain: DNSDomain!
 }
 
+"""An enumeration."""
 enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
   """RSA"""
   A_1
@@ -1923,6 +2452,7 @@ enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
   A_4
 }
 
+"""An enumeration."""
 enum DnsmanagerSshFingerprintRecordTypeChoices {
   """SHA-1"""
   A_1
@@ -1931,12 +2461,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 +2558,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 +2604,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
@@ -2079,50 +2636,43 @@ type StripeCustomer {
 
 type Billing {
   stripeCustomer: StripeCustomer!
-  payments: [PaymentIntent]!
-  paymentMethods: [PaymentMethod]!
+  payments: [PaymentIntent]! @deprecated(reason: "Use `payment_connection` instead")
+  subscriptions: [WasmerSubscription]!
+  paymentMethods: [PaymentMethod]! @deprecated(reason: "Use `payment_connection` instead")
+  paymentConnection(offset: Int, before: String, after: String, first: Int, last: Int): PaymentIntentConnection!
+  paymentMethodConnection(offset: Int, before: String, after: String, first: Int, last: Int): CardPaymentMethodConnection!
 }
 
 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!
+  currency: String!
+  status: String!
+  invoicePdfUrl: 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
+type WasmerSubscription implements Node {
+  """The datetime this object was created in stripe."""
+  created: DateTime
 
-  """The funds are in your account."""
-  SUCCEEDED
+  """The ID of the object"""
+  id: ID!
+  cancelAt: DateTime
+  canceledAt: DateTime
+  currentPeriodEnd: DateTime
+  currentPeriodStart: DateTime
+  daysUntilDue: Int
+  endedAt: DateTime
+  startDate: DateTime
+  status: String
+  trialEnd: DateTime
+  trialStart: DateTime
+  description: String
+  cancelAtPeriodEnd: Boolean
 }
 
 union PaymentMethod = CardPaymentMethod
@@ -2167,6 +2717,46 @@ enum CardFunding {
   UNKNOWN
 }
 
+type PaymentIntentConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PaymentIntentEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PaymentIntent` and its cursor."""
+type PaymentIntentEdge {
+  """The item at the end of the edge"""
+  node: PaymentIntent
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type CardPaymentMethodConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [CardPaymentMethodEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `CardPaymentMethod` and its cursor."""
+type CardPaymentMethodEdge {
+  """The item at the end of the edge"""
+  node: CardPaymentMethod
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
 type Payment {
   id: ID
   amount: String
@@ -2335,9 +2925,39 @@ input WorkloadRunnerWasmSourceV1 {
   webc: WebcSourceV1!
 }
 
+type GithubAppInstallation implements Node {
+  """The ID of the object"""
+  id: ID!
+  slug: String!
+  githubConfigureUrl: String!
+  repositories(filterByName: String): [GithubInstallationRepository]!
+}
+
+type GithubInstallationRepository implements Node {
+  """The ID of the object"""
+  id: ID!
+  repoUrl: String!
+  installation: GithubAppInstallation!
+  url: String!
+  name: String!
+  namespace: String!
+}
+
+type GithubRepoConnection implements Node {
+  """The ID of the object"""
+  id: ID!
+  githubRepoInstallation: GithubInstallationRepository!
+  connectedBy: User!
+  deployBranch: String!
+  app: DeployApp!
+  pullRequestComments: Boolean!
+  connectedAt: DateTime!
+  deploymentStatusEvents: Boolean!
+}
+
 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!
@@ -2349,17 +2969,28 @@ type Query {
     owner: String
   ): DeployApp
   getAppByGlobalAlias(alias: String!): DeployApp
+  autobuildDeploymentStatus(buildId: UUID!): AutobuildDeploymentStatus
   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!
   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!
+  rollout(id: ID!): Rollout
+  githubRollout(id: ID!): GitHubRollout
   viewer: User
   getUser(username: String!): User
   getPasswordResetToken(token: String!): GetPasswordResetToken
@@ -2405,18 +3036,20 @@ type Query {
   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
+  getSignedUrlForPackageUpload(name: String, version: String = "latest", filename: String, expiresAfterSeconds: Int = 60, method: String): 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 +3090,9 @@ type AppRegion implements Node {
   name: String!
   country: String!
   city: String!
+  supportsVolumes: Boolean!
+  supportsDbs: Boolean!
+  active: Boolean!
 
   """The ID of the object"""
   id: ID!
@@ -2487,6 +3123,12 @@ enum DNSRecordsSortBy {
   OLDEST
 }
 
+type AutobuildDeploymentStatus {
+  buildId: UUID!
+  status: StatusEnum!
+  appVersion: DeployAppVersion
+}
+
 type TemplateFrameworkConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -2527,6 +3169,7 @@ type TemplateLanguageEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum AppTemplatesSortBy {
   NEWEST
   OLDEST
@@ -2562,6 +3205,7 @@ type SecretLog implements Node {
   secretName: String!
 }
 
+"""An enumeration."""
 enum DeploySecretLogActionChoices {
   """Access"""
   ACCESS
@@ -2596,11 +3240,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 +3306,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 +3346,7 @@ type BlogPost implements Node {
   editUrl: String
 }
 
+"""An enumeration."""
 enum BlogBlogPostThemeChoices {
   """Green"""
   GREEN
@@ -2733,7 +3410,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 +3503,7 @@ enum PackageOrderBy {
 
 input NamespacesFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter namespaces by package count."""
   packageCount: CountFilter
@@ -2856,7 +3533,7 @@ enum NamespaceOrderBy {
 
 input UsersFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter users by package count."""
   packageCount: CountFilter
@@ -2882,7 +3559,7 @@ enum UserOrderBy {
 
 input AppFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter apps by deployed by."""
   deployedBy: String
@@ -2910,7 +3587,7 @@ enum AppOrderBy {
 
 input BlogPostsFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter blog posts by tag."""
   tags: [String]
@@ -2918,10 +3595,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 +3612,7 @@ input AppTemplateFilter {
 
 enum AppTemplateOrderBy {
   CREATED_DATE
+  HIGHLIGHTED
 }
 
 enum SearchKind {
@@ -2945,6 +3623,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 +3679,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 +3730,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 +3763,72 @@ 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
+  updateBuildConfig(input: UpdateBuildConfigInput!): UpdateBuildConfigPayload
+
+  """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
+
+  """Connect a github repo to an app."""
+  connectGithubRepoToApp(input: ConnectGithubRepoToAppInput!): ConnectGithubRepoToAppPayload
+
+  """Disconnect a github repo from an app."""
+  disconnectGithubRepoFromApp(input: DisconnectGithubRepoFromAppInput!): DisconnectGithubRepoFromAppPayload
+  updateGithubRepoConnection(input: UpdateGithubRepoAppConnectionInput!): UpdateGithubRepoAppConnectionPayload
+
+  """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 +3861,10 @@ type Mutation {
   mfa2RecoveryAuth(input: MFARecoveryAuthInput!): MFAAuthResponse
   mfa2EmailAuth(input: MFAEmailAuthInput!): MFAAuthResponse
   mfa2EmailGetToken(input: MFAGenerateEmailOTPInput!): MFAEmailGenerationResponse
+  generateCheckoutUrl(input: GenerateCheckoutUrlInput!): GenerateCheckoutUrlPayload
+  createCheckoutSession(input: CreateCheckoutSessionInput!): CreateCheckoutSessionPayload
+  cancelSubscription(input: CancelSubscriptionInput!): CancelSubscriptionPayload
+  renewCanceledSubscription(input: RenewCanceledSubscriptionInput!): RenewCanceledSubscriptionPayload
   publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
   publishPackage(input: PublishPackageInput!): PublishPackagePayload
   pushPackageRelease(input: PushPackageReleaseInput!): PushPackageReleasePayload
@@ -3126,6 +3910,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 +4086,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,9 +4200,19 @@ input GenerateDeployConfigTokenInput {
   clientMutationId: String
 }
 
-type RenameAppPayload {
-  success: Boolean!
-  app: DeployApp!
+type GenerateSshTokenPayload {
+  token: String!
+  clientMutationId: String
+}
+
+input GenerateSshTokenInput {
+  appId: ID
+  clientMutationId: String
+}
+
+type RenameAppPayload {
+  success: Boolean!
+  app: DeployApp!
   clientMutationId: String
 }
 
@@ -3389,6 +4347,7 @@ input UpsertDNSRecordInput {
   clientMutationId: String
 }
 
+"""An enumeration."""
 enum RecordKind {
   A
   AAAA
@@ -3532,6 +4491,468 @@ 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
+}
+
+type UpdateBuildConfigPayload {
+  buildConfig: BuildConfiguration!
+  success: Boolean!
+  clientMutationId: String
+}
+
+input UpdateBuildConfigInput {
+  appId: ID!
+  presetName: String
+  startCmd: String
+  buildCmd: String
+  installCmd: String
+  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] @deprecated(reason: "This field is not used anymore")
+  clientMutationId: String
+}
+
+"""The Build Configuration for a given repo"""
+type BuildConfig {
+  startCmd: String
+  buildCmd: String
+  installCmd: String
+  setupDb: Boolean!
+  presetName: String!
+  appName: String!
+  completionTimeInSeconds: Int!
+  branch: String
+  canDeployWithoutRepo: Boolean! @deprecated(reason: "This field is not used anymore")
+}
+
+input AutobuildConfigForRepoInput {
+  """The repo URL"""
+  repoUrl: String!
+
+  """The path to build from"""
+  basePath: String @deprecated(reason: "Please use root_dir instead")
+
+  """The root directory to build from"""
+  rootDir: String
+
+  """The branch to use"""
+  branch: 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] @deprecated(reason: "This field is not used anymore")
+  clientMutationId: String
+}
+
+input AutobuildConfigForZipUploadInput {
+  """The Zip upload URL"""
+  uploadUrl: String!
+  clientMutationId: String
+}
+
+"""Add a new github app installation"""
+type InstallGithubAppPayload {
+  success: Boolean!
+  user: User!
+  installation: GithubAppInstallation
+  clientMutationId: String
+}
+
+input InstallGithubAppInput {
+  """Github app Installation ID"""
+  installationId: ID!
+
+  """Github App Account ID"""
+  githubAccountId: ID
+
+  """Github App Account Login"""
+  githubAccountLogin: String
+  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
+}
+
+"""Connect a github repo to an app."""
+type ConnectGithubRepoToAppPayload {
+  app: DeployApp!
+  githubRepoConnection: GithubRepoConnection!
+  success: Boolean!
+  clientMutationId: String
+}
+
+input ConnectGithubRepoToAppInput {
+  """The ID of the App"""
+  appId: ID!
+
+  """The ID of the Github app repository installation"""
+  installationRepoId: ID!
+
+  """The branch to deploy from"""
+  deployBranch: String
+  clientMutationId: String
+}
+
+"""Disconnect a github repo from an app."""
+type DisconnectGithubRepoFromAppPayload {
+  app: DeployApp!
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DisconnectGithubRepoFromAppInput {
+  """The ID of the App"""
+  appId: ID!
+  clientMutationId: String
+}
+
+type UpdateGithubRepoAppConnectionPayload {
+  githubRepoConnection: GithubRepoConnection!
+  success: Boolean!
+  clientMutationId: String
+}
+
+input UpdateGithubRepoAppConnectionInput {
+  """The ID of the GithubRepoConnection"""
+  connectionId: ID!
+  deploymentStatusEvents: Boolean
+  pullRequestComments: Boolean
+  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
+  startCmd: 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
+
+  """The path to build from (defaults to /)"""
+  basePath: String @deprecated(reason: "Please use root_dir instead")
+
+  """The root directory to build from (defaults to /)"""
+  rootDir: 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 +5014,14 @@ type RegisterUserPayload {
 }
 
 input RegisterUserInput {
-  fullName: String!
+  fullName: String
   email: String!
   username: CaseInsensitiveString!
   password: String!
   acceptedTos: Boolean
   intent: String
+  fingerprintVisitorId: String
+  enterProTrial: Boolean
   clientMutationId: String
 }
 
@@ -3613,6 +5036,9 @@ input SocialAuthJWTInput {
   accessToken: String!
   register: Boolean = false
   registerIntent: String
+  fingerprintVisitorId: String
+  enterProTrial: Boolean
+  response: JSONString
   clientMutationId: String
 }
 
@@ -3652,7 +5078,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 +5135,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 +5158,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 +5336,86 @@ input MFAGenerateEmailOTPInput {
   clientMutationId: String
 }
 
+type GenerateCheckoutUrlPayload {
+  checkout: StripeCheckout!
+  clientMutationId: String
+}
+
+type StripeCheckout {
+  url: String!
+  expiresAt: DateTime!
+  clientSecret: String!
+}
+
+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
+}
+
+type CreateCheckoutSessionPayload {
+  clientSecret: String!
+  clientMutationId: String
+}
+
+input CreateCheckoutSessionInput {
+  """URL to redirect."""
+  returnUrl: 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
+
+  """Whether to apply a trial period if available."""
+  isTrial: Boolean = false
+  clientMutationId: String
+}
+
+type CancelSubscriptionPayload {
+  ok: Boolean!
+  clientMutationId: String
+}
+
+input CancelSubscriptionInput {
+  """ID of owner whose subscription to cancel."""
+  forOwnerId: ID!
+
+  """ID of the subscription to cancel"""
+  subscriptionId: ID!
+  clientMutationId: String
+}
+
+type RenewCanceledSubscriptionPayload {
+  ok: Boolean!
+  clientMutationId: String
+}
+
+input RenewCanceledSubscriptionInput {
+  """ID of owner whose subscription to renew."""
+  forOwnerId: ID!
+
+  """ID of the subscription to renew"""
+  subscriptionId: ID!
+  clientMutationId: String
+}
+
 type PublishPublicKeyPayload {
   success: Boolean!
   publicKey: PublicKey!
@@ -3932,12 +5447,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 +5478,7 @@ input InputSignature {
   data: String!
 }
 
+"""An enumeration."""
 enum UploadFormat {
   targz
   webcv2
@@ -4012,7 +5536,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 +5631,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 +5656,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 @)
@@ -4343,6 +5876,7 @@ input MakePackagePublicInput {
 
 type GenerateUploadUrlPayload {
   signedUrl: SignedUrl!
+  method: String!
   clientMutationId: String
 }
 
@@ -4351,13 +5885,28 @@ input GenerateUploadUrlInput {
   version: String = "latest"
   filename: String
   expiresAfterSeconds: Int = 60
+  method: String
   clientMutationId: String
 }
 
 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 +5931,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 +5941,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..8e28f7ef2d 100644
--- a/lib/backend-api/src/client.rs
+++ b/lib/backend-api/src/client.rs
@@ -2,13 +2,18 @@
 use std::time::Duration;
 
 use crate::GraphQLApiFailure;
-use anyhow::{bail, Context as _};
-use cynic::{http::CynicReqwestError, GraphQlResponse, Operation};
+use anyhow::{Context as _, bail};
+use cynic::{GraphQlResponse, Operation, http::CynicReqwestError};
+#[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.
+/// Use the queries in [`crate::query`] to interact with the API.
 #[derive(Clone, Debug)]
 pub struct WasmerClient {
     auth_token: Option<String>,
@@ -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(
@@ -58,9 +63,8 @@ impl WasmerClient {
                 "" => false,
                 other => {
                     bail!(
-                        "invalid value for {} - expected 0/false|1/true: '{}'",
-                        Self::ENV_VAR_LOG_VARIABLES,
-                        other
+                        "invalid value for {} - expected 0/false|1/true: '{other}'",
+                        Self::ENV_VAR_LOG_VARIABLES
                     );
                 }
             }
@@ -75,21 +79,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 +113,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
@@ -200,16 +200,16 @@ impl WasmerClient {
             }
         };
 
-        if let Some(errors) = &res.errors {
-            if !errors.is_empty() {
-                tracing::warn!(
-                    ?errors,
-                    data=?res.data,
-                    %query,
-                    endpoint=%self.graphql_endpoint,
-                    "GraphQL query succeeded, but returned errors",
-                );
-            }
+        if let Some(errors) = &res.errors
+            && !errors.is_empty()
+        {
+            tracing::warn!(
+                ?errors,
+                data=?res.data,
+                %query,
+                endpoint=%self.graphql_endpoint,
+                "GraphQL query succeeded, but returned errors",
+            );
         }
 
         Ok(res)
@@ -247,11 +247,11 @@ impl WasmerClient {
     {
         let res = self.run_graphql_raw(operation).await?;
 
-        if let Some(errs) = res.errors {
-            if !errs.is_empty() {
-                let errs = GraphQLApiFailure { errors: errs };
-                return Err(errs).context("GraphQL query failed");
-            }
+        if let Some(errs) = res.errors
+            && !errs.is_empty()
+        {
+            let errs = GraphQLApiFailure { errors: errs };
+            return Err(errs).context("GraphQL query failed");
         }
 
         if let Some(data) = res.data {
diff --git a/lib/backend-api/src/error.rs b/lib/backend-api/src/error.rs
index 76f5fa90c1..97d3e53006 100644
--- a/lib/backend-api/src/error.rs
+++ b/lib/backend-api/src/error.rs
@@ -11,11 +11,11 @@ impl GraphQLApiFailure {
         errors: Option<Vec<cynic::GraphQlError>>,
     ) -> anyhow::Error {
         let msg = msg.into();
-        if let Some(errs) = errors {
-            if !errs.is_empty() {
-                let err = GraphQLApiFailure { errors: errs };
-                return anyhow::Error::new(err).context(msg);
-            }
+        if let Some(errs) = errors
+            && !errs.is_empty()
+        {
+            let err = GraphQLApiFailure { errors: errs };
+            return anyhow::Error::new(err).context(msg);
         }
         anyhow::anyhow!("{msg} - query did not return any data")
     }
@@ -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..e6aacba0b2 100644
--- a/lib/backend-api/src/global_id.rs
+++ b/lib/backend-api/src/global_id.rs
@@ -1,6 +1,6 @@
 //! [`GlobalId`]s are used by the backend to identify a specific object.
 //!
-//! This module provides a parser/encoder and related type defintions
+//! This module provides a parser/encoder and related type definitions
 //! for global ids.
 
 use std::fmt::Display;
@@ -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..6fc918c148 100644
--- a/lib/backend-api/src/query.rs
+++ b/lib/backend-api/src/query.rs
@@ -1,18 +1,19 @@
 use std::{collections::HashSet, time::Duration};
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 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, *},
     GraphQLApiFailure, WasmerClient,
+    types::{self, *},
 };
 
 /// Rotate the s3 secrets tied to an app given its id.
@@ -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}/{}:{}",
@@ -384,7 +449,7 @@ pub async fn fetch_webc_package(
         ))?,
         PackageIdent::Hash(h) => match get_package_release(client, &h.to_string()).await? {
             Some(webc) => Url::parse(&webc.webc_url)?,
-            None => anyhow::bail!("Could not find package with hash '{}'", h),
+            None => anyhow::bail!("Could not find package with hash '{h}'"),
         },
     };
 
@@ -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.
@@ -776,6 +841,20 @@ pub fn fetch_all_app_template_frameworks(
     )
 }
 
+/// Upload method.
+#[derive(Debug)]
+pub enum UploadMethod {
+    R2,
+}
+
+impl UploadMethod {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            UploadMethod::R2 => "R2",
+        }
+    }
+}
+
 /// Get a signed URL to upload packages.
 pub async fn get_signed_url_for_package_upload(
     client: &WasmerClient,
@@ -783,6 +862,7 @@ pub async fn get_signed_url_for_package_upload(
     filename: Option<&str>,
     name: Option<&str>,
     version: Option<&str>,
+    method: Option<UploadMethod>,
 ) -> Result<Option<SignedUrl>, anyhow::Error> {
     client
         .run_graphql_strict(types::GetSignedUrlForPackageUpload::build(
@@ -791,11 +871,64 @@ pub async fn get_signed_url_for_package_upload(
                 filename,
                 name,
                 version,
+                method: method.map(|m| m.as_str()),
             },
         ))
         .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>,
+    method: Option<UploadMethod>,
+) -> Result<SignedUrl, anyhow::Error> {
+    let payload = client
+        .run_graphql_strict(types::GenerateUploadUrl::build(
+            GenerateUploadUrlVariables {
+                expires_after_seconds,
+                filename,
+                name,
+                version,
+                method: method.map(|m| m.as_str()),
+            },
+        ))
+        .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 +1143,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 +1430,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 +1474,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 +1538,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 +1596,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 +1835,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 +1849,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 +1859,27 @@ pub async fn generate_deploy_config_token_raw(
         .context("no token returned")
 }
 
+/// Generate an SSH token for accessing 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.
@@ -1743,7 +1978,7 @@ fn get_app_logs(
 /// Get pages of logs associated with an application that lie within the
 /// specified date range.
 ///
-/// In contrast to [`get_app_logs`], this function collects the stream into a
+/// In contrast to `get_app_logs`, this function collects the stream into a
 /// final vector.
 #[tracing::instrument(skip_all, level = "debug")]
 #[allow(clippy::let_with_type_underscore)]
@@ -1780,7 +2015,7 @@ pub async fn get_app_logs_paginated(
 /// Get pages of logs associated with an application that lie within the
 /// specified date range with a specific instance identifier.
 ///
-/// In contrast to [`get_app_logs`], this function collects the stream into a
+/// In contrast to `get_app_logs`, this function collects the stream into a
 /// final vector.
 #[tracing::instrument(skip_all, level = "debug")]
 #[allow(clippy::let_with_type_underscore)]
@@ -1827,7 +2062,7 @@ pub async fn get_app_logs_paginated_filter_instance(
 /// Get pages of logs associated with an specific request for application that lie within the
 /// specified date range.
 ///
-/// In contrast to [`get_app_logs`], this function collects the stream into a
+/// In contrast to `get_app_logs`, this function collects the stream into a
 /// final vector.
 #[tracing::instrument(skip_all, level = "debug")]
 #[allow(clippy::let_with_type_underscore)]
@@ -1882,8 +2117,7 @@ pub async fn get_domain(
 
     let opt = client
         .run_graphql(types::GetDomain::build(vars))
-        .await
-        .map_err(anyhow::Error::from)?
+        .await?
         .get_domain;
     Ok(opt)
 }
@@ -1899,8 +2133,7 @@ pub async fn get_domain_zone_file(
 
     let opt = client
         .run_graphql(types::GetDomainWithZoneFile::build(vars))
-        .await
-        .map_err(anyhow::Error::from)?
+        .await?
         .get_domain;
     Ok(opt)
 }
@@ -1914,8 +2147,7 @@ pub async fn get_domain_with_records(
 
     let opt = client
         .run_graphql(types::GetDomainWithRecords::build(vars))
-        .await
-        .map_err(anyhow::Error::from)?
+        .await?
         .get_domain;
     Ok(opt)
 }
@@ -1934,8 +2166,7 @@ pub async fn register_domain(
     };
     let opt = client
         .run_graphql_strict(types::RegisterDomain::build(vars))
-        .await
-        .map_err(anyhow::Error::from)?
+        .await?
         .register_domain
         .context("Domain registration failed")?
         .domain
@@ -1953,7 +2184,6 @@ pub async fn get_all_dns_records(
     client
         .run_graphql_strict(types::GetAllDnsRecords::build(vars))
         .await
-        .map_err(anyhow::Error::from)
         .map(|x| x.get_all_dnsrecords)
 }
 
@@ -1965,7 +2195,6 @@ pub async fn get_all_domains(
     let connection = client
         .run_graphql_strict(types::GetAllDomains::build(vars))
         .await
-        .map_err(anyhow::Error::from)
         .map(|x| x.get_all_domains)
         .context("no domains returned")?;
     Ok(connection
@@ -2018,7 +2247,6 @@ pub async fn purge_cache_for_app_version(
     client
         .run_graphql_strict(types::PurgeCacheForAppVersion::build(vars))
         .await
-        .map_err(anyhow::Error::from)
         .map(|x| x.purge_cache_for_app_version)
         .context("backend did not return data")?;
 
diff --git a/lib/backend-api/src/stream.rs b/lib/backend-api/src/stream.rs
index c2a8f8eb1f..89a5d681e3 100644
--- a/lib/backend-api/src/stream.rs
+++ b/lib/backend-api/src/stream.rs
@@ -1,8 +1,8 @@
 use std::{collections::VecDeque, task::Poll};
 
 use futures::{
-    future::{BoxFuture, OptionFuture},
     Future,
+    future::{BoxFuture, OptionFuture},
 };
 
 use super::WasmerClient;
@@ -106,10 +106,9 @@ impl<Q: PaginatedQuery> futures::Stream for QueryStream<Q> {
                 this.items.extend(items);
                 this.fut.set(None.into());
 
-                if let Some(item) = this.items.pop_front() {
-                    Poll::Ready(Some(Ok(item)))
-                } else {
-                    Poll::Ready(None)
+                match this.items.pop_front() {
+                    Some(item) => Poll::Ready(Some(Ok(item))),
+                    _ => Poll::Ready(None),
                 }
             }
             Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err))),
diff --git a/lib/backend-api/src/subscription.rs b/lib/backend-api/src/subscription.rs
new file mode 100644
index 0000000000..016ede5270
--- /dev/null
+++ b/lib/backend-api/src/subscription.rs
@@ -0,0 +1,121 @@
+use crate::{
+    WasmerClient,
+    types::{
+        AutobuildDeploymentSubscription, AutobuildDeploymentSubscriptionVariables,
+        PackageVersionReadySubscription, PackageVersionReadySubscriptionVariables, Uuid,
+    },
+};
+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..874ac896ef 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;
@@ -297,7 +303,7 @@ mod queries {
         pub cursor: String,
     }
 
-    #[derive(serde::Serialize, cynic::QueryFragment, PartialEq, Eq, Debug)]
+    #[derive(serde::Serialize, cynic::QueryFragment, PartialEq, Eq, Debug, Clone)]
     pub struct AppTemplate {
         #[serde(rename = "demoUrl")]
         pub demo_url: String,
@@ -320,6 +326,10 @@ mod queries {
         pub updated_at: DateTime,
         #[serde(rename = "useCases")]
         pub use_cases: Jsonstring,
+        #[serde(rename = "branch")]
+        pub branch: Option<String>,
+        #[serde(rename = "rootDir")]
+        pub root_dir: Option<String>,
     }
 
     #[derive(cynic::QueryVariables, Debug, Clone)]
@@ -574,6 +584,7 @@ mod queries {
         pub filename: Option<&'a str>,
         pub name: Option<&'a str>,
         pub version: Option<&'a str>,
+        pub method: Option<&'a str>,
     }
 
     #[derive(cynic::QueryFragment, Debug)]
@@ -582,7 +593,7 @@ mod queries {
         variables = "GetSignedUrlForPackageUploadVariables"
     )]
     pub struct GetSignedUrlForPackageUpload {
-        #[arguments(name: $name, version: $version, filename: $filename, expiresAfterSeconds: $expires_after_seconds)]
+        #[arguments(name: $name, version: $version, filename: $filename, expiresAfterSeconds: $expires_after_seconds, method: $method)]
         pub get_signed_url_for_package_upload: Option<SignedUrl>,
     }
 
@@ -591,6 +602,29 @@ 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>,
+        pub method: 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, method: $method })]
+        pub generate_upload_url: Option<GenerateUploadUrlPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct GenerateUploadUrlPayload {
+        #[cynic(rename = "signedUrl")]
+        pub signed_url: SignedUrl,
+        pub method: String,
+    }
+
     #[derive(cynic::QueryFragment, Debug)]
     pub struct PackageWebcConnection {
         pub page_info: PageInfo,
@@ -632,6 +666,7 @@ mod queries {
 
     #[derive(cynic::QueryVariables, Debug)]
     pub struct GetCurrentUserWithAppsVars {
+        pub first: Option<i32>,
         pub after: Option<String>,
         pub sort: Option<DeployAppsSortBy>,
     }
@@ -648,7 +683,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 +867,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 +879,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 +1018,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 +1264,193 @@ 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,
+        Failed,
+        Queued,
+        Timeout,
+        InternalError,
+        Cancelled,
+        Running,
+    }
+
+    impl StatusEnum {
+        pub fn as_str(&self) -> &'static str {
+            match self {
+                Self::Success => "success",
+                Self::Working => "working",
+                Self::Failed => "failed",
+                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>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct BuildConfig {
+        pub build_cmd: Option<String>,
+        pub install_cmd: Option<String>,
+        pub start_cmd: Option<String>,
+        pub setup_db: bool,
+        pub preset_name: String,
+        pub app_name: String,
+        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 +1550,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 +1602,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 +1785,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 +2397,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 +2501,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..0bba0c1500 100644
--- a/lib/c-api/Cargo.toml
+++ b/lib/c-api/Cargo.toml
@@ -18,87 +18,125 @@ 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 = "=7.0.0", path = "../api", default-features = false, package = "wasmer" }
+wasmer-compiler = { version = "=7.0.0", path = "../compiler", optional = true }
+wasmer-compiler-cranelift = { version = "=7.0.0", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { version = "=7.0.0", path = "../compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { version = "=7.0.0", path = "../compiler-singlepass", optional = true }
+wasmer-middlewares = { version = "=7.0.0", path = "../middlewares", optional = true }
+wasmer-types = { version = "=7.0.0", path = "../types" }
+wasmer-wasix = { path = "../wasix", version = "=0.700.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.700.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"
-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",
-] }
+thiserror.workspace = true
+typetag = { workspace = true, optional = true }
+paste.workspace = true
+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"
+field-offset.workspace = true
 
 [target.'cfg(target_os = "windows")'.dev-dependencies]
-wasmer-inline-c = "0.1.1"
+wasmer-inline-c.workspace = true
 
 [target.'cfg(not(target_os = "windows"))'.dev-dependencies]
-inline-c = "0.1.7"
+inline-c.workspace = true
 
 [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",
 ]
-llvm = [
-    "wasmer-compiler-llvm",
-    "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",
 ]
+
+# 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,8 @@ 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 = { workspace = true, default-features = false }
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage_nightly)'] }
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..a423084cee 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}");
     }
 }
 
@@ -335,13 +330,15 @@ fn shared_object_dir() -> PathBuf {
     assert_eq!(shared_object_dir.file_name(), Some(OsStr::new("out")));
     shared_object_dir.pop();
 
-    assert!(shared_object_dir
-        .file_name()
-        .as_ref()
-        .unwrap()
-        .to_string_lossy()
-        .to_string()
-        .starts_with("wasmer-c-api"));
+    assert!(
+        shared_object_dir
+            .file_name()
+            .as_ref()
+            .unwrap()
+            .to_string_lossy()
+            .to_string()
+            .starts_with("wasmer-c-api")
+    );
     shared_object_dir.pop();
 
     assert_eq!(shared_object_dir.file_name(), Some(OsStr::new("build")));
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..36fae2abad 100644
--- a/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
+++ b/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "wasmer-capi-examples-runner"
-version = "4.3.7"
-edition = "2021"
-license = "MIT"
 description = "wasmer-capi-examples-runner"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
 
 [dependencies]
-cc = "1.0"
-target-lexicon = "0.11"
-regex = "1.6"
-walkdir = "2.3.2"
\ No newline at end of file
+cc.workspace = true
+target-lexicon.workspace = true
+regex.workspace = true
+walkdir.workspace = true
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..769b670176 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.
@@ -87,7 +87,7 @@ pub(crate) fn take_last_error() -> Option<String> {
 ///
 /// See this module's documentation to get a complete example.
 // TODO(Amanieu): This should use size_t
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_last_error_length() -> c_int {
     LAST_ERROR.with(|prev| match *prev.borrow() {
         Some(ref err) => err.len() as c_int + 1,
@@ -118,7 +118,7 @@ pub extern "C" fn wasmer_last_error_length() -> c_int {
 ///
 /// See this module's documentation to get a complete example.
 // TODO(Amanieu): This should use size_t
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_last_error_message(
     buffer: Option<NonNull<c_char>>,
     length: c_int,
@@ -142,13 +142,15 @@ pub unsafe extern "C" fn wasmer_last_error_message(
         return -1;
     }
 
-    let buffer = slice::from_raw_parts_mut(buffer.cast::<u8>().as_ptr(), length);
+    let buffer = unsafe { slice::from_raw_parts_mut(buffer.cast::<u8>().as_ptr(), length) };
 
-    ptr::copy_nonoverlapping(
-        error_message.as_ptr(),
-        buffer.as_mut_ptr(),
-        error_message.len(),
-    );
+    unsafe {
+        ptr::copy_nonoverlapping(
+            error_message.as_ptr(),
+            buffer.as_mut_ptr(),
+            error_message.len(),
+        );
+    }
 
     // Add a trailing null so people using the string as a `char *` don't
     // accidentally read into garbage.
diff --git a/lib/c-api/src/lib.rs b/lib/c-api/src/lib.rs
index 82a3fa12c2..9beeebaa43 100644
--- a/lib/c-api/src/lib.rs
+++ b/lib/c-api/src/lib.rs
@@ -25,8 +25,11 @@
 )]
 // 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)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![allow(non_camel_case_types)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod error;
 pub mod tracing;
diff --git a/lib/c-api/src/tracing.rs b/lib/c-api/src/tracing.rs
index e63e356835..9a8406a0ff 100644
--- a/lib/c-api/src/tracing.rs
+++ b/lib/c-api/src/tracing.rs
@@ -31,11 +31,11 @@
 use std::ffi::c_int;
 
 use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 const WHITELISTED_LOG_TARGETS: &[&str] = &["wasmer", "wasmer_wasix", "virtual_fs"];
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_setup_tracing(verbosity_level: c_int, use_color: c_int) {
     let fmt_layer = fmt::layer()
         .with_target(true)
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..29022cd94d
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/mod.rs
@@ -0,0 +1,142 @@
+#[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),
+            #[cfg(feature = "wasmi")]
+            super::wasmer_backend_t::WASMI => Self::Wasmi(wasmi::wasmer_wasmi_engine_config_t),
+            #[cfg(feature = "wamr")]
+            super::wasmer_backend_t::WAMR => Self::Wamr(wamr::wasmer_wamr_engine_config_t),
+            #[cfg(feature = "jsc")]
+            super::wasmer_backend_t::JSC => Self::Jsc(jsc::wasmer_jsc_engine_config_t),
+
+            #[allow(unreachable_patterns)]
+            _ => 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();
+/// # }
+/// ```
+#[unsafe(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 [`wasmer_middlewares::metering`] module.
+#[unsafe(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..29079eef0d
--- /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();
+/// # }
+/// ```
+#[unsafe(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..494dff80ed
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/mod.rs
@@ -0,0 +1,311 @@
+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,
+}
+
+#[unsafe(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
+#[unsafe(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
+#[unsafe(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),
+        #[allow(unreachable_patterns)]
+        _ => 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
+#[unsafe(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
+#[unsafe(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();
+/// # }
+/// ```
+#[unsafe(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;
+
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
+    #[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/externals/function.rs b/lib/c-api/src/wasm_c_api/externals/function.rs
index e72c277edd..ed6c55d483 100644
--- a/lib/c-api/src/wasm_c_api/externals/function.rs
+++ b/lib/c-api/src/wasm_c_api/externals/function.rs
@@ -42,7 +42,7 @@ pub type wasm_func_callback_with_env_t = unsafe extern "C" fn(
 #[allow(non_camel_case_types)]
 pub type wasm_env_finalizer_t = unsafe extern "C" fn(*mut c_void);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_new(
     store: Option<&mut wasm_store_t>,
     function_type: Option<&wasm_functype_t>,
@@ -51,7 +51,7 @@ pub unsafe extern "C" fn wasm_func_new(
     let function_type = function_type?;
     let callback = callback?;
     let store = store?;
-    let mut store_mut = store.inner.store_mut();
+    let mut store_mut = unsafe { store.inner.store_mut() };
 
     let func_sig = &function_type.inner().function_type;
     let num_rets = func_sig.results().len();
@@ -74,7 +74,7 @@ pub unsafe extern "C" fn wasm_func_new(
         ]
         .into();
 
-        let trap = callback(&processed_args, &mut results);
+        let trap = unsafe { callback(&processed_args, &mut results) };
 
         if let Some(trap) = trap {
             return Err(trap.inner);
@@ -96,7 +96,7 @@ pub unsafe extern "C" fn wasm_func_new(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_new_with_env(
     store: Option<&mut wasm_store_t>,
     function_type: Option<&wasm_functype_t>,
@@ -107,7 +107,7 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
     let function_type = function_type?;
     let callback = callback?;
     let store = store?;
-    let mut store_mut = store.inner.store_mut();
+    let mut store_mut = unsafe { store.inner.store_mut() };
 
     let func_sig = &function_type.inner().function_type;
     let num_rets = func_sig.results().len();
@@ -126,12 +126,11 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
 
     impl Drop for WrapperEnv {
         fn drop(&mut self) {
-            if let Ok(mut guard) = self.env_finalizer.lock() {
-                if Arc::strong_count(&self.env_finalizer) == 1 {
-                    if let Some(env_finalizer) = guard.take() {
-                        unsafe { (env_finalizer)(self.env.as_ptr()) };
-                    }
-                }
+            if let Ok(mut guard) = self.env_finalizer.lock()
+                && Arc::strong_count(&self.env_finalizer) == 1
+                && let Some(env_finalizer) = guard.take()
+            {
+                unsafe { (env_finalizer)(self.env.as_ptr()) };
             }
         }
     }
@@ -154,7 +153,7 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
         ]
         .into();
 
-        let trap = callback(env.data().env.as_ptr(), &processed_args, &mut results);
+        let trap = unsafe { callback(env.data().env.as_ptr(), &processed_args, &mut results) };
 
         if let Some(trap) = trap {
             return Err(trap.inner);
@@ -185,15 +184,15 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_func_copy(func: &wasm_func_t) -> Box<wasm_func_t> {
     Box::new(func.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_delete(_func: Option<Box<wasm_func_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_call(
     func: Option<&mut wasm_func_t>,
     args: Option<&wasm_val_vec_t>,
@@ -202,7 +201,7 @@ pub unsafe extern "C" fn wasm_func_call(
     let func = func?;
     let args = args?;
     let mut store = func.extern_.store.clone();
-    let mut store_mut = store.store_mut();
+    let mut store_mut = unsafe { store.store_mut() };
     let params = args
         .as_slice()
         .iter()
@@ -227,30 +226,25 @@ pub unsafe extern "C" fn wasm_func_call(
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_param_arity(func: &wasm_func_t) -> usize {
-    func.extern_
-        .function()
-        .ty(&func.extern_.store.store())
-        .params()
-        .len()
+    let store_ref = unsafe { func.extern_.store.store() };
+    func.extern_.function().ty(&store_ref).params().len()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_result_arity(func: &wasm_func_t) -> usize {
-    func.extern_
-        .function()
-        .ty(&func.extern_.store.store())
-        .results()
-        .len()
+    let store_ref = unsafe { func.extern_.store.store() };
+    func.extern_.function().ty(&store_ref).results().len()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_func_type(
     func: Option<&wasm_func_t>,
 ) -> Option<Box<wasm_functype_t>> {
     let func = func?;
+    let store_ref = unsafe { func.extern_.store.store() };
     Some(Box::new(wasm_functype_t::new(
-        func.extern_.function().ty(&func.extern_.store.store()),
+        func.extern_.function().ty(&store_ref),
     )))
 }
diff --git a/lib/c-api/src/wasm_c_api/externals/global.rs b/lib/c-api/src/wasm_c_api/externals/global.rs
index 1c1519dcd6..6c4080258d 100644
--- a/lib/c-api/src/wasm_c_api/externals/global.rs
+++ b/lib/c-api/src/wasm_c_api/externals/global.rs
@@ -21,7 +21,7 @@ impl wasm_global_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_new(
     store: Option<&mut wasm_store_t>,
     global_type: Option<&wasm_globaltype_t>,
@@ -29,7 +29,7 @@ pub unsafe extern "C" fn wasm_global_new(
 ) -> Option<Box<wasm_global_t>> {
     let global_type = global_type?;
     let store = store?;
-    let mut store_mut = store.inner.store_mut();
+    let mut store_mut = unsafe { store.inner.store_mut() };
     let val = val?;
 
     let global_type = &global_type.inner().global_type;
@@ -44,40 +44,38 @@ pub unsafe extern "C" fn wasm_global_new(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_delete(_global: Option<Box<wasm_global_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_copy(global: &wasm_global_t) -> Box<wasm_global_t> {
     // do shallow copy
     Box::new(global.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_get(
     global: &mut wasm_global_t,
     // own
     out: &mut wasm_val_t,
 ) {
-    let value = global
-        .extern_
-        .global()
-        .get(&mut global.extern_.store.store_mut());
+    let wasm_global = global.extern_.global();
+    let mut store_mut = unsafe { global.extern_.store.store_mut() };
+    let value = wasm_global.get(&mut store_mut);
     *out = value.try_into().unwrap();
 }
 
 /// Note: This function returns nothing by design but it can raise an
 /// error if setting a new value fails.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_set(global: &mut wasm_global_t, val: &wasm_val_t) {
     let value: Value = val.try_into().unwrap();
-    c_try!(global
-        .extern_
-        .global()
-        .set(&mut global.extern_.store.store_mut(), value); otherwise ());
+    let wasm_global = global.extern_.global();
+    let mut store_mut = unsafe { global.extern_.store.store_mut() };
+    c_try!(wasm_global.set(&mut store_mut, value); otherwise ());
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_same(
     wasm_global1: &wasm_global_t,
     wasm_global2: &wasm_global_t,
@@ -85,13 +83,14 @@ pub unsafe extern "C" fn wasm_global_same(
     wasm_global1.extern_.global() == wasm_global2.extern_.global()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_global_type(
     global: Option<&wasm_global_t>,
 ) -> Option<Box<wasm_globaltype_t>> {
     let global = global?;
+    let store_ref = unsafe { global.extern_.store.store() };
     Some(Box::new(wasm_globaltype_t::new(
-        global.extern_.global().ty(&global.extern_.store.store()),
+        global.extern_.global().ty(&store_ref),
     )))
 }
 
@@ -102,7 +101,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_set_host_global_immutable() {
         (assert_c! {
@@ -135,7 +138,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_set_guest_global_immutable() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/externals/memory.rs b/lib/c-api/src/wasm_c_api/externals/memory.rs
index a919ec98cb..d2e7d1a7a1 100644
--- a/lib/c-api/src/wasm_c_api/externals/memory.rs
+++ b/lib/c-api/src/wasm_c_api/externals/memory.rs
@@ -18,14 +18,14 @@ impl wasm_memory_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_new(
     store: Option<&mut wasm_store_t>,
     memory_type: Option<&wasm_memorytype_t>,
 ) -> Option<Box<wasm_memory_t>> {
     let memory_type = memory_type?;
     let store = store?;
-    let mut store_mut = store.inner.store_mut();
+    let mut store_mut = unsafe { store.inner.store_mut() };
     let memory_type = memory_type.inner().memory_type;
     let memory = c_try!(Memory::new(&mut store_mut, memory_type));
     Some(Box::new(wasm_memory_t {
@@ -33,16 +33,16 @@ pub unsafe extern "C" fn wasm_memory_new(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_delete(_memory: Option<Box<wasm_memory_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_copy(memory: &wasm_memory_t) -> Box<wasm_memory_t> {
     // do shallow copy
     Box::new(memory.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_same(
     wasm_memory1: &wasm_memory_t,
     wasm_memory2: &wasm_memory_t,
@@ -50,55 +50,42 @@ pub unsafe extern "C" fn wasm_memory_same(
     wasm_memory1.extern_.memory() == wasm_memory2.extern_.memory()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_type(
     memory: Option<&wasm_memory_t>,
 ) -> Option<Box<wasm_memorytype_t>> {
     let memory = memory?;
+    let store_ref = unsafe { memory.extern_.store.store() };
     Some(Box::new(wasm_memorytype_t::new(
-        memory.extern_.memory().ty(&memory.extern_.store.store()),
+        memory.extern_.memory().ty(&store_ref),
     )))
 }
 
 // get a raw pointer into bytes
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_data(memory: &mut wasm_memory_t) -> *mut u8 {
-    memory
-        .extern_
-        .memory()
-        .view(&memory.extern_.store.store())
-        .data_ptr()
+    let store_ref = unsafe { memory.extern_.store.store() };
+    memory.extern_.memory().view(&store_ref).data_ptr()
 }
 
 // size in bytes
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_data_size(memory: &wasm_memory_t) -> usize {
-    memory
-        .extern_
-        .memory()
-        .view(&memory.extern_.store.store())
-        .size()
-        .bytes()
-        .0
+    let store_ref = unsafe { memory.extern_.store.store() };
+    memory.extern_.memory().view(&store_ref).size().bytes().0
 }
 
 // size in pages
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_size(memory: &wasm_memory_t) -> u32 {
-    memory
-        .extern_
-        .memory()
-        .view(&memory.extern_.store.store())
-        .size()
-        .0 as _
+    let store_ref = unsafe { memory.extern_.store.store() };
+    memory.extern_.memory().view(&store_ref).size().0 as _
 }
 
 // delta is in pages
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memory_grow(memory: &mut wasm_memory_t, delta: u32) -> bool {
-    memory
-        .extern_
-        .memory()
-        .grow(&mut memory.extern_.store.store_mut(), Pages(delta))
-        .is_ok()
+    let wasm_memory = memory.extern_.memory();
+    let mut store_mut = unsafe { memory.extern_.store.store_mut() };
+    wasm_memory.grow(&mut store_mut, Pages(delta)).is_ok()
 }
diff --git a/lib/c-api/src/wasm_c_api/externals/mod.rs b/lib/c-api/src/wasm_c_api/externals/mod.rs
index a6a2e4e851..b5c893a1b5 100644
--- a/lib/c-api/src/wasm_c_api/externals/mod.rs
+++ b/lib/c-api/src/wasm_c_api/externals/mod.rs
@@ -52,7 +52,7 @@ impl wasm_extern_t {
     }
 }
 
-// #[no_mangle]
+// #[unsafe(no_mangle)]
 // pub extern "C" fn wasm_extern_kind(e: &wasm_extern_t) -> wasm_externkind_t {
 //     (match e.inner {
 //         Extern::Function(_) => wasm_externkind_enum::WASM_EXTERN_FUNC,
@@ -64,7 +64,8 @@ impl wasm_extern_t {
 
 impl wasm_extern_t {
     pub(crate) unsafe fn ty(&self) -> ExternType {
-        self.inner.ty(&self.store.store())
+        let store_ref = unsafe { self.store.store() };
+        self.inner.ty(&store_ref)
     }
 }
 
@@ -77,55 +78,55 @@ impl From<wasm_extern_t> for Extern {
 wasm_declare_boxed_vec!(extern);
 
 /// Copy a `wasm_extern_t`.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_extern_copy(r#extern: &wasm_extern_t) -> Box<wasm_extern_t> {
     Box::new(r#extern.clone())
 }
 
 /// Delete an extern.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_extern_delete(_extern: Option<Box<wasm_extern_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_func_as_extern(func: Option<&wasm_func_t>) -> Option<&wasm_extern_t> {
     Some(&func?.extern_)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_global_as_extern(global: Option<&wasm_global_t>) -> Option<&wasm_extern_t> {
     Some(&global?.extern_)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_memory_as_extern(memory: Option<&wasm_memory_t>) -> Option<&wasm_extern_t> {
     Some(&memory?.extern_)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_table_as_extern(table: Option<&wasm_table_t>) -> Option<&wasm_extern_t> {
     Some(&table?.extern_)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_extern_as_func(r#extern: Option<&wasm_extern_t>) -> Option<&wasm_func_t> {
     wasm_func_t::try_from(r#extern?)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_extern_as_global(
     r#extern: Option<&wasm_extern_t>,
 ) -> Option<&wasm_global_t> {
     wasm_global_t::try_from(r#extern?)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_extern_as_memory(
     r#extern: Option<&wasm_extern_t>,
 ) -> Option<&wasm_memory_t> {
     wasm_memory_t::try_from(r#extern?)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_extern_as_table(r#extern: Option<&wasm_extern_t>) -> Option<&wasm_table_t> {
     wasm_table_t::try_from(r#extern?)
 }
@@ -137,7 +138,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_extern_copy() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/externals/table.rs b/lib/c-api/src/wasm_c_api/externals/table.rs
index 839cb447f1..b0ecfeac8d 100644
--- a/lib/c-api/src/wasm_c_api/externals/table.rs
+++ b/lib/c-api/src/wasm_c_api/externals/table.rs
@@ -19,7 +19,7 @@ impl wasm_table_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_new(
     _store: Option<&wasm_store_t>,
     _table_type: Option<&wasm_tabletype_t>,
@@ -28,21 +28,22 @@ pub unsafe extern "C" fn wasm_table_new(
     todo!("get val from init somehow");
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_delete(_table: Option<Box<wasm_table_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_copy(table: &wasm_table_t) -> Box<wasm_table_t> {
     // do shallow copy
     Box::new(table.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_size(table: &wasm_table_t) -> usize {
-    table.extern_.table().size(&table.extern_.store.store()) as _
+    let store_ref = unsafe { table.extern_.store.store() };
+    table.extern_.table().size(&store_ref) as _
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_same(
     wasm_table1: &wasm_table_t,
     wasm_table2: &wasm_table_t,
@@ -50,7 +51,7 @@ pub unsafe extern "C" fn wasm_table_same(
     wasm_table1.extern_.table() == wasm_table2.extern_.table()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_table_grow(
     _table: &mut wasm_table_t,
     _delta: wasm_table_size_t,
diff --git a/lib/c-api/src/wasm_c_api/function_env.rs b/lib/c-api/src/wasm_c_api/function_env.rs
index a9e3910ab0..f3a1f82778 100644
--- a/lib/c-api/src/wasm_c_api/function_env.rs
+++ b/lib/c-api/src/wasm_c_api/function_env.rs
@@ -45,7 +45,7 @@ pub struct wasmer_funcenv_t {
     inner: FunctionCEnv,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_funcenv_new(
     store: Option<&mut wasm_store_t>,
     mut data: *mut c_void,
@@ -54,10 +54,11 @@ pub unsafe extern "C" fn wasmer_funcenv_new(
     if data.is_null() {
         data = &NULL_ENV_PLACEHOLDER as *const u32 as *mut u32 as *mut c_void;
     }
-    let inner = FunctionCEnv::new(std::ptr::NonNull::new_unchecked(data));
-    let _ = FunctionEnv::new(&mut store.inner.store_mut(), inner);
+    let inner = FunctionCEnv::new(unsafe { std::ptr::NonNull::new_unchecked(data) });
+    let mut store_mut = unsafe { store.inner.store_mut() };
+    let _ = FunctionEnv::new(&mut store_mut, inner);
     Some(Box::new(wasmer_funcenv_t { inner }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_funcenv_delete(_funcenv: Option<Box<wasmer_funcenv_t>>) {}
diff --git a/lib/c-api/src/wasm_c_api/instance.rs b/lib/c-api/src/wasm_c_api/instance.rs
index ab07dff657..0268a3d1a8 100644
--- a/lib/c-api/src/wasm_c_api/instance.rs
+++ b/lib/c-api/src/wasm_c_api/instance.rs
@@ -1,6 +1,6 @@
 use super::externals::{wasm_extern_t, wasm_extern_vec_t};
 use super::module::wasm_module_t;
-use super::store::{wasm_store_t, StoreRef};
+use super::store::{StoreRef, wasm_store_t};
 use super::trap::wasm_trap_t;
 use wasmer_api::{Extern, Instance, InstantiationError};
 
@@ -34,7 +34,7 @@ pub struct wasm_instance_t {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_instance_new(
     store: Option<&mut wasm_store_t>,
     module: Option<&wasm_module_t>,
@@ -42,7 +42,7 @@ pub unsafe extern "C" fn wasm_instance_new(
     trap: Option<&mut *mut wasm_trap_t>,
 ) -> Option<Box<wasm_instance_t>> {
     let store = store?;
-    let mut store_mut = store.inner.store_mut();
+    let mut store_mut = unsafe { store.inner.store_mut() };
     let module = module?;
     let imports = imports?;
 
@@ -104,7 +104,7 @@ pub unsafe extern "C" fn wasm_instance_new(
 /// # Example
 ///
 /// See [`wasm_instance_new`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_instance_delete(_instance: Option<Box<wasm_instance_t>>) {}
 
 /// Gets the exports of the instance.
@@ -190,7 +190,7 @@ pub unsafe extern "C" fn wasm_instance_delete(_instance: Option<Box<wasm_instanc
 /// * [`wasm_extern_as_global`][super::externals::wasm_extern_as_global],
 /// * [`wasm_extern_as_table`][super::externals::wasm_extern_as_table],
 /// * [`wasm_extern_as_memory`][super::externals::wasm_extern_as_memory].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_instance_exports(
     instance: &wasm_instance_t,
     // own
@@ -218,7 +218,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_instance_new() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/macros.rs b/lib/c-api/src/wasm_c_api/macros.rs
index 19a3090255..1cf82862fe 100644
--- a/lib/c-api/src/wasm_c_api/macros.rs
+++ b/lib/c-api/src/wasm_c_api/macros.rs
@@ -142,7 +142,7 @@ int main() {
 #    .success();
 # }
 ```")]
-        #[no_mangle]
+        #[unsafe(no_mangle)]
         pub extern "C" fn $empty(out: &mut $name) {
             out.size = 0;
             out.data = std::ptr::null_mut();
@@ -175,7 +175,7 @@ int main() {
 #    .success();
 # }
 ```")]
-        #[no_mangle]
+        #[unsafe(no_mangle)]
         pub extern "C" fn $uninit(out: &mut $name, size: usize) {
             out.set_buffer(vec![Default::default(); size]);
         }
@@ -185,14 +185,14 @@ int main() {
 # Example
 
 See the [`", stringify!($name), "`] type to get an example.")]
-        #[no_mangle]
+        #[unsafe(no_mangle)]
         pub unsafe extern "C" fn $new(out: &mut $name, size: usize, ptr: *const $elem_ty) {
-            let vec = (0..size).map(|i| ptr.add(i).read()).collect();
+            let vec = (0..size).map(|i| unsafe { ptr.add(i).read() }).collect();
             out.set_buffer(vec);
         }
 
         #[doc = concat!("Performs a deep copy of a vector of [`", $c_ty, "`].")]
-        #[no_mangle]
+        #[unsafe(no_mangle)]
         pub extern "C" fn $copy(out: &mut $name, src: &$name) {
             out.set_buffer(src.as_slice().to_vec());
         }
@@ -202,7 +202,7 @@ See the [`", stringify!($name), "`] type to get an example.")]
 # Example
 
 See the [`", stringify!($name), "`] type to get an example.")]
-        #[no_mangle]
+        #[unsafe(no_mangle)]
         pub extern "C" fn $delete(out: &mut $name) {
             out.take();
         }
@@ -264,7 +264,7 @@ macro_rules! wasm_impl_copy {
 
     ($name:ident, $prefix:ident) => {
         paste::paste! {
-            #[no_mangle]
+            #[unsafe(no_mangle)]
             pub extern "C" fn [<$prefix _ $name _copy>](src: Option<&[<$prefix _ $name _t>]>) -> Option<Box<[<$prefix _ $name _t>]>> {
                 Some(Box::new(src?.clone()))
             }
@@ -279,7 +279,7 @@ macro_rules! wasm_impl_delete {
 
     ($name:ident, $prefix:ident) => {
         paste::paste! {
-            #[no_mangle]
+            #[unsafe(no_mangle)]
             pub extern "C" fn [<$prefix _ $name _delete>](_: Option<Box<[<$prefix _ $name _t>]>>) {}
         }
     };
diff --git a/lib/c-api/src/wasm_c_api/module.rs b/lib/c-api/src/wasm_c_api/module.rs
index 2bc7b1ff3b..dd011abebf 100644
--- a/lib/c-api/src/wasm_c_api/module.rs
+++ b/lib/c-api/src/wasm_c_api/module.rs
@@ -24,15 +24,16 @@ pub struct wasm_module_t {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_new(
     store: Option<&mut wasm_store_t>,
     bytes: Option<&wasm_byte_vec_t>,
 ) -> Option<Box<wasm_module_t>> {
-    let store = store?.inner.store_mut();
+    let store = store?;
+    let store_mut = unsafe { store.inner.store_mut() };
     let bytes = bytes?;
 
-    let module = c_try!(Module::from_binary(&store, bytes.as_slice()));
+    let module = c_try!(Module::from_binary(&store_mut, bytes.as_slice()));
 
     Some(Box::new(wasm_module_t { inner: module }))
 }
@@ -42,7 +43,7 @@ pub unsafe extern "C" fn wasm_module_new(
 /// # Example
 ///
 /// See [`wasm_module_new`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_delete(_module: Option<Box<wasm_module_t>>) {}
 
 /// Validates a new WebAssembly module given the configuration
@@ -86,13 +87,13 @@ pub unsafe extern "C" fn wasm_module_delete(_module: Option<Box<wasm_module_t>>)
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_validate(
     store: Option<&mut wasm_store_t>,
     bytes: Option<&wasm_byte_vec_t>,
 ) -> bool {
     let store = match store {
-        Some(store) => store.inner.store_mut(),
+        Some(store) => unsafe { store.inner.store_mut() },
         None => return false,
     };
     let bytes = match bytes {
@@ -213,7 +214,7 @@ pub unsafe extern "C" fn wasm_module_validate(
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_exports(
     module: &wasm_module_t,
     // own
@@ -253,7 +254,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;
@@ -353,7 +354,7 @@ pub unsafe extern "C" fn wasm_module_exports(
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_imports(
     module: &wasm_module_t,
     // own
@@ -451,18 +452,19 @@ pub unsafe extern "C" fn wasm_module_imports(
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_deserialize(
     store: &wasm_store_t,
     bytes: Option<&wasm_byte_vec_t>,
 ) -> Option<NonNull<wasm_module_t>> {
     let bytes = bytes?;
 
-    let module = c_try!(Module::deserialize(&store.inner.store(), bytes.as_slice()));
+    let store_ref = unsafe { store.inner.store() };
+    let module = c_try!(unsafe { Module::deserialize(&store_ref, bytes.as_slice()) });
 
-    Some(NonNull::new_unchecked(Box::into_raw(Box::new(
-        wasm_module_t { inner: module },
-    ))))
+    Some(unsafe {
+        NonNull::new_unchecked(Box::into_raw(Box::new(wasm_module_t { inner: module })))
+    })
 }
 
 /// Serializes a module into a binary representation that the
@@ -472,7 +474,7 @@ pub unsafe extern "C" fn wasm_module_deserialize(
 /// # Example
 ///
 /// See [`wasm_module_deserialize`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_module_serialize(module: &wasm_module_t, out: &mut wasm_byte_vec_t) {
     let byte_vec = c_try!(module.inner.serialize(); otherwise ());
     out.set_buffer(byte_vec.to_vec());
@@ -485,7 +487,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_validate() {
         (assert_c! {
@@ -513,7 +519,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_new() {
         (assert_c! {
@@ -543,7 +553,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_exports() {
         (assert_c! {
@@ -652,7 +666,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_imports() {
         (assert_c! {
@@ -668,7 +686,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;
@@ -771,7 +789,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_serialize() {
         (assert_c! {
@@ -806,7 +828,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_module_serialize_and_deserialize() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/store.rs b/lib/c-api/src/wasm_c_api/store.rs
index 24c6b0627a..ecb72ac16a 100644
--- a/lib/c-api/src/wasm_c_api/store.rs
+++ b/lib/c-api/src/wasm_c_api/store.rs
@@ -10,11 +10,11 @@ pub struct StoreRef {
 
 impl StoreRef {
     pub unsafe fn store(&self) -> BaseStoreRef<'_> {
-        (*self.inner.get()).as_store_ref()
+        unsafe { (*self.inner.get()).as_store_ref() }
     }
 
     pub unsafe fn store_mut(&mut self) -> StoreMut<'_> {
-        (*self.inner.get()).as_store_mut()
+        unsafe { (*self.inner.get()).as_store_mut() }
     }
 }
 
@@ -29,12 +29,12 @@ pub struct wasm_store_t {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 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 {
@@ -48,5 +48,5 @@ pub unsafe extern "C" fn wasm_store_new(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_store_delete(_store: Option<Box<wasm_store_t>>) {}
diff --git a/lib/c-api/src/wasm_c_api/trap.rs b/lib/c-api/src/wasm_c_api/trap.rs
index 390e8a96b5..953e10673f 100644
--- a/lib/c-api/src/wasm_c_api/trap.rs
+++ b/lib/c-api/src/wasm_c_api/trap.rs
@@ -24,7 +24,7 @@ impl From<RuntimeError> for wasm_trap_t {
 /// # Example
 ///
 /// See the module's documentation for a complete example.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_trap_new(
     _store: &mut wasm_store_t,
     message: &wasm_message_t,
@@ -63,7 +63,7 @@ pub unsafe extern "C" fn wasm_trap_new(
 /// # Example
 ///
 /// See the module's documentation for a complete example.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_trap_delete(_trap: Option<Box<wasm_trap_t>>) {}
 
 /// Gets the message attached to the trap.
@@ -108,7 +108,7 @@ pub unsafe extern "C" fn wasm_trap_delete(_trap: Option<Box<wasm_trap_t>>) {}
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_trap_message(
     trap: &wasm_trap_t,
     // own
@@ -122,13 +122,13 @@ pub unsafe extern "C" fn wasm_trap_message(
 }
 
 /// Gets the origin frame attached to the trap.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_trap_origin(trap: &wasm_trap_t) -> Option<Box<wasm_frame_t>> {
     trap.inner.trace().first().map(Into::into).map(Box::new)
 }
 
 /// Gets the trace (as a list of frames) attached to the trap.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_trap_trace(
     trap: &wasm_trap_t,
     // own
@@ -150,7 +150,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_trap_message_null_terminated() {
         (assert_c! {
@@ -183,7 +187,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_trap_message_not_null_terminated() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/types/export.rs b/lib/c-api/src/wasm_c_api/types/export.rs
index a60ccf48b4..cccd3807a9 100644
--- a/lib/c-api/src/wasm_c_api/types/export.rs
+++ b/lib/c-api/src/wasm_c_api/types/export.rs
@@ -11,7 +11,7 @@ pub struct wasm_exporttype_t {
 wasm_declare_boxed_vec!(exporttype);
 wasm_impl_copy_delete!(exporttype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_exporttype_new(
     name: &wasm_name_t,
     extern_type: Box<wasm_externtype_t>,
@@ -22,12 +22,12 @@ pub extern "C" fn wasm_exporttype_new(
     })
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_exporttype_name(export_type: &wasm_exporttype_t) -> &wasm_name_t {
     &export_type.name
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_exporttype_type(export_type: &wasm_exporttype_t) -> &wasm_externtype_t {
     &export_type.extern_type
 }
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..522daa7a31 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,
+    WasmFunctionType, WasmGlobalType, WasmMemoryType, WasmTableType, WasmTagType, wasm_functype_t,
+    wasm_globaltype_t, wasm_memorytype_t, wasm_tabletype_t,
 };
 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)),
             },
         }
     }
@@ -83,25 +89,27 @@ impl From<&ExternType> for wasm_externtype_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_extern_type(r#extern: &wasm_extern_t) -> Box<wasm_externtype_t> {
-    Box::new(wasm_externtype_t::new(r#extern.ty()))
+    let ty = unsafe { r#extern.ty() };
+    Box::new(wasm_externtype_t::new(ty))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_extern_kind(r#extern: &wasm_extern_t) -> wasm_externkind_t {
-    wasm_externkind_enum::from(r#extern.ty()) as wasm_externkind_t
+    let ty = unsafe { r#extern.ty() };
+    wasm_externkind_enum::from(ty) as wasm_externkind_t
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_delete(_extern_type: Option<Box<wasm_externtype_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_externtype_copy(extern_type: &wasm_externtype_t) -> Box<wasm_externtype_t> {
     Box::new(extern_type.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_kind(
     extern_type: &wasm_externtype_t,
 ) -> wasm_externkind_t {
@@ -110,6 +118,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
 }
 
@@ -171,112 +180,112 @@ impl TryFrom<&'static wasm_externtype_t> for &'static wasm_memorytype_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_functype_const(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_functype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_functype(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_functype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_functype_as_externtype_const(
     function_type: &'static wasm_functype_t,
 ) -> &'static wasm_externtype_t {
     &function_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_functype_as_externtype(
     function_type: &'static wasm_functype_t,
 ) -> &'static wasm_externtype_t {
     &function_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_globaltype_const(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_globaltype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_globaltype(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_globaltype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_as_externtype_const(
     global_type: &'static wasm_globaltype_t,
 ) -> &'static wasm_externtype_t {
     &global_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_as_externtype(
     global_type: &'static wasm_globaltype_t,
 ) -> &'static wasm_externtype_t {
     &global_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_tabletype_const(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_tabletype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_tabletype(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_tabletype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_as_externtype_const(
     table_type: &'static wasm_tabletype_t,
 ) -> &'static wasm_externtype_t {
     &table_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_as_externtype(
     table_type: &'static wasm_tabletype_t,
 ) -> &'static wasm_externtype_t {
     &table_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_memorytype_const(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_memorytype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_externtype_as_memorytype(
     extern_type: &'static wasm_externtype_t,
 ) -> Option<&'static wasm_memorytype_t> {
     Some(c_try!(extern_type.try_into()))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memorytype_as_externtype_const(
     memory_type: &'static wasm_memorytype_t,
 ) -> &'static wasm_externtype_t {
     &memory_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memorytype_as_externtype(
     memory_type: &'static wasm_memorytype_t,
 ) -> &'static wasm_externtype_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..c195cae9e6 100644
--- a/lib/c-api/src/wasm_c_api/types/frame.rs
+++ b/lib/c-api/src/wasm_c_api/types/frame.rs
@@ -21,30 +21,30 @@ impl From<FrameInfo> for wasm_frame_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_copy(frame: &wasm_frame_t) -> Box<wasm_frame_t> {
     Box::new(frame.clone())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_delete(_frame: Option<Box<wasm_frame_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_instance(_frame: &wasm_frame_t) -> *const wasm_instance_t {
     std::ptr::null()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_func_index(frame: &wasm_frame_t) -> u32 {
     frame.info.func_index()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_func_offset(frame: &wasm_frame_t) -> usize {
     frame.info.func_offset()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_module_offset(frame: &wasm_frame_t) -> usize {
     frame.info.module_offset()
 }
@@ -56,7 +56,7 @@ pub struct wasm_name_t {
     pub name: *mut c_char,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_module_name(frame: &wasm_frame_t) -> wasm_name_t {
     let module_name =
         Some(frame.info.module_name()).and_then(|f| Some(CString::new(f).ok()?.into_raw()));
@@ -69,7 +69,7 @@ pub unsafe extern "C" fn wasm_frame_module_name(frame: &wasm_frame_t) -> wasm_na
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_frame_func_name(frame: &wasm_frame_t) -> wasm_name_t {
     let func_name = frame
         .info
@@ -84,12 +84,12 @@ pub unsafe extern "C" fn wasm_frame_func_name(frame: &wasm_frame_t) -> wasm_name
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_name_delete(name: Option<&mut wasm_name_t>) {
-    if let Some(s) = name {
-        if !s.name.is_null() {
-            let _ = CString::from_raw(s.name);
-        }
+    if let Some(s) = name
+        && !s.name.is_null()
+    {
+        let _ = unsafe { CString::from_raw(s.name) };
     }
 }
 
@@ -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/function.rs b/lib/c-api/src/wasm_c_api/types/function.rs
index 52d10d54c5..747f6964b6 100644
--- a/lib/c-api/src/wasm_c_api/types/function.rs
+++ b/lib/c-api/src/wasm_c_api/types/function.rs
@@ -1,4 +1,4 @@
-use super::{wasm_externtype_t, wasm_valtype_vec_t, WasmExternType};
+use super::{WasmExternType, wasm_externtype_t, wasm_valtype_vec_t};
 use std::fmt;
 use wasmer_api::{ExternType, FunctionType};
 use wasmer_types::Type;
@@ -69,7 +69,7 @@ impl wasm_functype_t {
 wasm_declare_boxed_vec!(functype);
 wasm_impl_copy_delete!(functype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_functype_new(
     params: Option<&mut wasm_valtype_vec_t>,
     results: Option<&mut wasm_valtype_vec_t>,
@@ -94,7 +94,7 @@ pub unsafe extern "C" fn wasm_functype_new(
     ))))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_functype_params(
     function_type: Option<&wasm_functype_t>,
 ) -> Option<&wasm_valtype_vec_t> {
@@ -103,7 +103,7 @@ pub unsafe extern "C" fn wasm_functype_params(
     Some(&function_type.inner().params)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_functype_results(
     function_type: Option<&wasm_functype_t>,
 ) -> Option<&wasm_valtype_vec_t> {
diff --git a/lib/c-api/src/wasm_c_api/types/global.rs b/lib/c-api/src/wasm_c_api/types/global.rs
index b15d3e820e..c35d832245 100644
--- a/lib/c-api/src/wasm_c_api/types/global.rs
+++ b/lib/c-api/src/wasm_c_api/types/global.rs
@@ -1,6 +1,6 @@
 use super::{
-    wasm_externtype_t, wasm_mutability_enum, wasm_mutability_t, wasm_valtype_delete,
-    wasm_valtype_t, WasmExternType,
+    WasmExternType, wasm_externtype_t, wasm_mutability_enum, wasm_mutability_t,
+    wasm_valtype_delete, wasm_valtype_t,
 };
 use std::convert::TryInto;
 use wasmer_api::{ExternType, GlobalType};
@@ -48,7 +48,7 @@ impl wasm_globaltype_t {
 
 wasm_declare_boxed_vec!(globaltype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_new(
     valtype: Option<Box<wasm_valtype_t>>,
     mutability: wasm_mutability_t,
@@ -60,22 +60,24 @@ pub unsafe extern "C" fn wasm_globaltype_new(
         mutability.into(),
     )));
 
-    wasm_valtype_delete(Some(valtype));
+    unsafe {
+        wasm_valtype_delete(Some(valtype));
+    }
 
     Some(global_type)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_delete(_global_type: Option<Box<wasm_globaltype_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_mutability(
     global_type: &wasm_globaltype_t,
 ) -> wasm_mutability_t {
     wasm_mutability_enum::from(global_type.inner().global_type.mutability).into()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_globaltype_content(
     global_type: &wasm_globaltype_t,
 ) -> &wasm_valtype_t {
diff --git a/lib/c-api/src/wasm_c_api/types/import.rs b/lib/c-api/src/wasm_c_api/types/import.rs
index 8be6b99c11..9fcff330ba 100644
--- a/lib/c-api/src/wasm_c_api/types/import.rs
+++ b/lib/c-api/src/wasm_c_api/types/import.rs
@@ -13,7 +13,7 @@ pub struct wasm_importtype_t {
 wasm_declare_boxed_vec!(importtype);
 wasm_impl_copy!(importtype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_importtype_new(
     module: Option<&mut wasm_name_t>,
     name: Option<&mut wasm_name_t>,
@@ -26,22 +26,22 @@ pub extern "C" fn wasm_importtype_new(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_importtype_module(import_type: &wasm_importtype_t) -> &wasm_name_t {
     &import_type.module
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_importtype_name(import_type: &wasm_importtype_t) -> &wasm_name_t {
     &import_type.name
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_importtype_type(import_type: &wasm_importtype_t) -> &wasm_externtype_t {
     &import_type.extern_type
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_importtype_delete(_import_type: Option<Box<wasm_importtype_t>>) {}
 
 impl From<ImportType> for wasm_importtype_t {
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..003a8ac2ef 100644
--- a/lib/c-api/src/wasm_c_api/types/memory.rs
+++ b/lib/c-api/src/wasm_c_api/types/memory.rs
@@ -1,4 +1,4 @@
-use super::{wasm_externtype_t, WasmExternType};
+use super::{WasmExternType, wasm_externtype_t};
 use wasmer_api::{ExternType, MemoryType, Pages};
 
 #[derive(Debug, Clone)]
@@ -50,7 +50,7 @@ impl wasm_memorytype_t {
 
 wasm_declare_boxed_vec!(memorytype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Box<wasm_memorytype_t> {
     let min_pages = Pages(limits.min as _);
     let max_pages = if limits.max == LIMITS_MAX_SENTINEL {
@@ -64,7 +64,7 @@ pub unsafe extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Box<wasm
     )))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memorytype_delete(_memory_type: Option<Box<wasm_memorytype_t>>) {}
 
 #[allow(non_camel_case_types)]
@@ -75,9 +75,9 @@ 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]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_memorytype_limits(memory_type: &wasm_memorytype_t) -> &wasm_limits_t {
     &memory_type.inner().limits
 }
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..7fc650a007 100644
--- a/lib/c-api/src/wasm_c_api/types/table.rs
+++ b/lib/c-api/src/wasm_c_api/types/table.rs
@@ -1,12 +1,12 @@
 use super::{
-    wasm_externtype_t, wasm_limits_t, wasm_valtype_delete, wasm_valtype_t, WasmExternType,
+    WasmExternType, wasm_externtype_t, wasm_limits_t, wasm_valtype_delete, wasm_valtype_t,
 };
 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 {
@@ -55,7 +55,7 @@ impl wasm_tabletype_t {
 
 wasm_declare_boxed_vec!(tabletype);
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_new(
     valtype: Option<Box<wasm_valtype_t>>,
     limits: &wasm_limits_t,
@@ -72,20 +72,22 @@ pub unsafe extern "C" fn wasm_tabletype_new(
         max_elements,
     )));
 
-    wasm_valtype_delete(Some(valtype));
+    unsafe {
+        wasm_valtype_delete(Some(valtype));
+    }
 
     Some(table_type)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_limits(table_type: &wasm_tabletype_t) -> &wasm_limits_t {
     &table_type.inner().limits
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_element(table_type: &wasm_tabletype_t) -> &wasm_valtype_t {
     &table_type.inner().content
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_tabletype_delete(_table_type: Option<Box<wasm_tabletype_t>>) {}
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..5776a8c2cd 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,
         }
     }
 }
@@ -78,7 +81,7 @@ impl From<Type> for wasm_valtype_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_valtype_new(kind: wasm_valkind_t) -> Option<Box<wasm_valtype_t>> {
     let kind_enum = kind.try_into().ok()?;
     let valtype = wasm_valtype_t { valkind: kind_enum };
@@ -86,10 +89,10 @@ pub extern "C" fn wasm_valtype_new(kind: wasm_valkind_t) -> Option<Box<wasm_valt
     Some(Box::new(valtype))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_valtype_delete(_valtype: Option<Box<wasm_valtype_t>>) {}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_valtype_kind(valtype: Option<&wasm_valtype_t>) -> wasm_valkind_t {
     valtype
         .expect("`wasm_valtype_kind: argument is a null pointer")
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..2acb212081 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.
@@ -90,7 +44,7 @@ pub extern "C" fn wasm_config_set_target(config: &mut wasm_config_t, target: Box
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_config_set_features(
     config: &mut wasm_config_t,
     features: Box<wasmer_features_t>,
@@ -98,70 +52,27 @@ 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]
+#[unsafe(no_mangle)]
 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"))
+#[unsafe(no_mangle)]
+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)]
@@ -174,10 +85,12 @@ mod tests {
 
     #[test]
     fn test_wasmer_is_headless() {
-        set_var(
-            "COMPILER",
-            if cfg!(feature = "compiler") { "0" } else { "1" },
-        );
+        unsafe {
+            set_var(
+                "COMPILER",
+                if cfg!(feature = "compiler") { "0" } else { "1" },
+            );
+        }
 
         (assert_c! {
             #include "tests/wasmer.h"
@@ -191,67 +104,51 @@ mod tests {
         })
         .success();
 
-        remove_var("COMPILER");
-    }
-
-    #[test]
-    fn test_wasmer_is_compiler_available() {
-        set_var(
-            "CRANELIFT",
-            if cfg!(feature = "cranelift") {
-                "1"
-            } else {
-                "0"
-            },
-        );
-        set_var("LLVM", if cfg!(feature = "llvm") { "1" } else { "0" });
-        set_var(
-            "SINGLEPASS",
-            if cfg!(feature = "singlepass") {
-                "1"
-            } else {
-                "0"
-            },
-        );
-
-        (assert_c! {
-            #include "tests/wasmer.h"
-            #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'));
-
-                return 0;
-            }
-        })
-        .success();
-
-        remove_var("CRANELIFT");
-        remove_var("LLVM");
-        remove_var("SINGLEPASS");
+        unsafe {
+            remove_var("COMPILER");
+        }
     }
 
     #[test]
-    fn test_wasmer_is_engine_available() {
-        set_var(
-            "UNIVERSAL",
-            if cfg!(feature = "compiler") { "1" } else { "0" },
-        );
+    fn test_wasmer_is_backend_available() {
+        unsafe {
+            set_var(
+                "CRANELIFT",
+                if cfg!(feature = "cranelift") {
+                    "1"
+                } else {
+                    "0"
+                },
+            );
+            set_var("LLVM", if cfg!(feature = "llvm") { "1" } else { "0" });
+            set_var(
+                "SINGLEPASS",
+                if cfg!(feature = "singlepass") {
+                    "1"
+                } else {
+                    "0"
+                },
+            );
+        }
 
         (assert_c! {
             #include "tests/wasmer.h"
             #include <stdlib.h>
 
             int main() {
-                assert(wasmer_is_engine_available(UNIVERSAL) == (getenv("UNIVERSAL")[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;
             }
         })
         .success();
 
-        remove_var("UNIVERSAL");
+        unsafe {
+            remove_var("CRANELIFT");
+            remove_var("LLVM");
+            remove_var("SINGLEPASS");
+        }
     }
 }
diff --git a/lib/c-api/src/wasm_c_api/unstable/features.rs b/lib/c-api/src/wasm_c_api/unstable/features.rs
index b00cffb5b0..57c1837e5d 100644
--- a/lib/c-api/src/wasm_c_api/unstable/features.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/features.rs
@@ -53,7 +53,7 @@ pub struct wasmer_features_t {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_new() -> Box<wasmer_features_t> {
     Box::new(wasmer_features_t {
         inner: Features::new(),
@@ -65,7 +65,7 @@ pub extern "C" fn wasmer_features_new() -> Box<wasmer_features_t> {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_delete(_features: Option<Box<wasmer_features_t>>) {}
 
 /// Configures whether the WebAssembly threads proposal will be enabled.
@@ -84,7 +84,7 @@ pub extern "C" fn wasmer_features_delete(_features: Option<Box<wasmer_features_t
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_threads(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -118,7 +118,7 @@ pub extern "C" fn wasmer_features_threads(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_reference_types(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -151,7 +151,7 @@ pub extern "C" fn wasmer_features_reference_types(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_simd(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -184,7 +184,7 @@ pub extern "C" fn wasmer_features_simd(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_bulk_memory(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -217,7 +217,7 @@ pub extern "C" fn wasmer_features_bulk_memory(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_multi_value(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -249,7 +249,7 @@ pub extern "C" fn wasmer_features_multi_value(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_tail_call(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -282,7 +282,7 @@ pub extern "C" fn wasmer_features_tail_call(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_module_linking(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -315,7 +315,7 @@ pub extern "C" fn wasmer_features_module_linking(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_multi_memory(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
@@ -348,7 +348,7 @@ pub extern "C" fn wasmer_features_multi_memory(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_features_memory64(
     features: Option<&mut wasmer_features_t>,
     enable: bool,
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..5b122116f2 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
@@ -137,8 +137,8 @@ use super::wasmer_middleware_t;
 use std::sync::Arc;
 use wasmer_api::wasmparser::Operator;
 use wasmer_middlewares::{
-    metering::{get_remaining_points, set_remaining_points, MeteringPoints},
     Metering,
+    metering::{MeteringPoints, get_remaining_points, set_remaining_points},
 };
 
 /// Opaque type representing a metering middleware.
@@ -172,7 +172,7 @@ pub type wasmer_metering_cost_function_t =
 /// # Example
 ///
 /// See module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_metering_new(
     initial_limit: u64,
     cost_function: wasmer_metering_cost_function_t,
@@ -189,7 +189,7 @@ pub extern "C" fn wasmer_metering_new(
 /// # Example
 ///
 /// See module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_metering_delete(_metering: Option<Box<wasmer_metering_t>>) {}
 
 /// Returns the remaining metering points. `u64::MAX` means
@@ -200,13 +200,14 @@ pub extern "C" fn wasmer_metering_delete(_metering: Option<Box<wasmer_metering_t
 /// # Example
 ///
 /// See module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_metering_get_remaining_points(
     instance: &mut wasm_instance_t,
 ) -> u64 {
-    match get_remaining_points(&mut instance.store.store_mut(), &instance.inner) {
+    let mut store_mut = unsafe { instance.store.store_mut() };
+    match get_remaining_points(&mut store_mut, &instance.inner) {
         MeteringPoints::Remaining(value) => value,
-        MeteringPoints::Exhausted => std::u64::MAX,
+        MeteringPoints::Exhausted => u64::MAX,
     }
 }
 
@@ -215,12 +216,13 @@ pub unsafe extern "C" fn wasmer_metering_get_remaining_points(
 /// # Example
 ///
 /// See module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_metering_points_are_exhausted(
     instance: &mut wasm_instance_t,
 ) -> bool {
+    let mut store_mut = unsafe { instance.store.store_mut() };
     matches!(
-        get_remaining_points(&mut instance.store.store_mut(), &instance.inner),
+        get_remaining_points(&mut store_mut, &instance.inner),
         MeteringPoints::Exhausted,
     )
 }
@@ -297,24 +299,25 @@ pub unsafe extern "C" fn wasmer_metering_points_are_exhausted(
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_metering_set_remaining_points(
     instance: &mut wasm_instance_t,
     new_limit: u64,
 ) {
-    set_remaining_points(&mut instance.store.store_mut(), &instance.inner, new_limit);
+    let mut store_mut = unsafe { instance.store.store_mut() };
+    set_remaining_points(&mut store_mut, &instance.inner, new_limit);
 }
 
 /// Transforms a [`wasmer_metering_t`] into a generic
 /// [`wasmer_middleware_t`], to then be pushed in the configuration with
-/// [`wasm_config_push_middleware`][super::wasm_config_push_middleware].
+/// [`wasm_config_push_middleware`](crate::wasm_c_api::engine::wasm_config_push_middleware).
 ///
 /// This function takes ownership of `metering`.
 ///
 /// # Example
 ///
 /// See module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_metering_as_middleware(
     metering: Option<Box<wasmer_metering_t>>,
 ) -> Option<Box<wasmer_middleware_t>> {
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..149ee23e1c 100644
--- a/lib/c-api/src/wasm_c_api/unstable/module.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/module.rs
@@ -55,7 +55,7 @@ use wasmer_api::Module;
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_module_name(
     module: &wasm_module_t,
     // own
@@ -139,7 +139,7 @@ pub unsafe extern "C" fn wasmer_module_name(
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_module_set_name(
     module: &mut wasm_module_t,
     // own
@@ -167,12 +167,12 @@ pub unsafe extern "C" fn wasmer_module_set_name(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 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..66d8130d53 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.
@@ -79,7 +79,7 @@ pub struct wasmer_target_t {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_target_new(
     triple: Option<Box<wasmer_triple_t>>,
     cpu_features: Option<Box<wasmer_cpu_features_t>>,
@@ -97,7 +97,7 @@ pub extern "C" fn wasmer_target_new(
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_target_delete(_target: Option<Box<wasmer_target_t>>) {}
 
 /// Unstable non-standard Wasmer-specific API to represent a target
@@ -142,15 +142,14 @@ pub struct wasmer_triple_t {
 /// # Example
 ///
 /// See [`wasmer_triple_t`] or [`wasmer_triple_new_from_host`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_triple_new(
     triple: Option<&wasm_name_t>,
 ) -> Option<Box<wasmer_triple_t>> {
     let triple = triple?;
-    let triple = c_try!(str::from_utf8(slice::from_raw_parts(
-        triple.data,
-        triple.size
-    )));
+    let triple = c_try!(str::from_utf8(unsafe {
+        slice::from_raw_parts(triple.data, triple.size)
+    }));
 
     Some(Box::new(wasmer_triple_t {
         inner: c_try!(Triple::from_str(triple)),
@@ -181,7 +180,7 @@ pub unsafe extern "C" fn wasmer_triple_new(
 /// ```
 ///
 /// See also [`wasmer_triple_new`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_triple_new_from_host() -> Box<wasmer_triple_t> {
     Box::new(wasmer_triple_t {
         inner: Triple::host(),
@@ -193,7 +192,7 @@ pub extern "C" fn wasmer_triple_new_from_host() -> Box<wasmer_triple_t> {
 /// # Example
 ///
 /// See [`wasmer_triple_t`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_triple_delete(_triple: Option<Box<wasmer_triple_t>>) {}
 
 /// Unstable non-standard Wasmer-specific API to represent a set of
@@ -263,7 +262,7 @@ pub struct wasmer_cpu_features_t {
 /// # Example
 ///
 /// See [`wasmer_cpu_features_t`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_cpu_features_new() -> Box<wasmer_cpu_features_t> {
     Box::new(wasmer_cpu_features_t {
         inner: CpuFeature::set(),
@@ -275,7 +274,7 @@ pub extern "C" fn wasmer_cpu_features_new() -> Box<wasmer_cpu_features_t> {
 /// # Example
 ///
 /// See [`wasmer_cpu_features_t`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_cpu_features_delete(_cpu_features: Option<Box<wasmer_cpu_features_t>>) {}
 
 /// Add a new CPU feature into the set represented by
@@ -284,7 +283,7 @@ pub extern "C" fn wasmer_cpu_features_delete(_cpu_features: Option<Box<wasmer_cp
 /// # Example
 ///
 /// See [`wasmer_cpu_features_t`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_cpu_features_add(
     cpu_features: Option<&mut wasmer_cpu_features_t>,
     feature: Option<&wasm_name_t>,
@@ -298,10 +297,12 @@ pub unsafe extern "C" fn wasmer_cpu_features_add(
         _ => return false,
     };
     let feature = c_try!(
-        str::from_utf8(slice::from_raw_parts(
-            feature.data,
-            feature.size,
-        ));
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(
+                feature.data,
+                feature.size,
+            )
+        });
         otherwise false
     );
 
diff --git a/lib/c-api/src/wasm_c_api/unstable/wasi.rs b/lib/c-api/src/wasm_c_api/unstable/wasi.rs
index f37a5e510f..0634bfd78c 100644
--- a/lib/c-api/src/wasm_c_api/unstable/wasi.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/wasi.rs
@@ -66,7 +66,7 @@ mod __cbindgen_hack__ {
         pub data: *mut *mut wasmer_named_extern_t,
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     pub unsafe extern "C" fn wasmer_named_extern_vec_new(
         out: *mut wasmer_named_extern_vec_t,
         length: usize,
@@ -75,7 +75,7 @@ mod __cbindgen_hack__ {
         unimplemented!()
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     pub unsafe extern "C" fn wasmer_named_extern_vec_new_uninitialized(
         out: *mut wasmer_named_extern_vec_t,
         length: usize,
@@ -83,7 +83,7 @@ mod __cbindgen_hack__ {
         unimplemented!()
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     pub unsafe extern "C" fn wasmer_named_extern_vec_copy(
         out_ptr: &mut wasmer_named_extern_vec_t,
         in_ptr: &wasmer_named_extern_vec_t,
@@ -91,14 +91,14 @@ mod __cbindgen_hack__ {
         unimplemented!()
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     pub unsafe extern "C" fn wasmer_named_extern_vec_delete(
         ptr: Option<&mut wasmer_named_extern_vec_t>,
     ) {
         unimplemented!()
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     pub unsafe extern "C" fn wasmer_named_extern_vec_new_empty(
         out: *mut wasmer_named_extern_vec_t,
     ) {
@@ -110,7 +110,7 @@ mod __cbindgen_hack__ {
 /// `wasmer_named_extern_t`.
 ///
 /// The returned value isn't owned by the caller.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_named_extern_module(
     named_extern: Option<&wasmer_named_extern_t>,
 ) -> Option<&wasm_name_t> {
@@ -120,7 +120,7 @@ pub extern "C" fn wasmer_named_extern_module(
 /// Non-standard function to get the name of a `wasmer_named_extern_t`.
 ///
 /// The returned value isn't owned by the caller.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_named_extern_name(
     named_extern: Option<&wasmer_named_extern_t>,
 ) -> Option<&wasm_name_t> {
@@ -131,7 +131,7 @@ pub extern "C" fn wasmer_named_extern_name(
 /// `wasmer_named_extern_t`.
 ///
 /// The returned value isn't owned by the caller.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_named_extern_unwrap(
     named_extern: Option<&wasmer_named_extern_t>,
 ) -> Option<&wasm_extern_t> {
@@ -142,13 +142,13 @@ pub extern "C" fn wasmer_named_extern_unwrap(
 /// implementation with no particular order. Each import has its
 /// associated module name and name, so that it can be re-order later
 /// based on the `wasm_module_t` requirements.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_get_unordered_imports(
     wasi_env: Option<&mut wasi_env_t>,
     module: Option<&wasm_module_t>,
     imports: &mut wasmer_named_extern_vec_t,
 ) -> bool {
-    wasi_get_unordered_imports_inner(wasi_env, module, imports).is_some()
+    unsafe { wasi_get_unordered_imports_inner(wasi_env, module, imports) }.is_some()
 }
 
 unsafe fn wasi_get_unordered_imports_inner(
@@ -158,10 +158,12 @@ unsafe fn wasi_get_unordered_imports_inner(
 ) -> Option<()> {
     let wasi_env = wasi_env?;
     let store = &mut wasi_env.store;
-    let mut store_mut = store.store_mut();
     let module = module?;
 
-    let import_object = c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner));
+    let import_object = {
+        let mut store_mut = unsafe { store.store_mut() };
+        c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner))
+    };
 
     imports.set_buffer(
         import_object
diff --git a/lib/c-api/src/wasm_c_api/value.rs b/lib/c-api/src/wasm_c_api/value.rs
index 737975fa88..920b70a7c5 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");
             }
@@ -129,14 +131,14 @@ impl Default for wasm_val_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_val_copy(
     // own
     out: &mut wasm_val_t,
     val: &wasm_val_t,
 ) {
     out.kind = val.kind;
-    out.of = c_try!(val.kind.try_into().map(|kind| {
+    out.of = c_try!(val.kind.try_into().map(|kind| unsafe {
         match kind {
             wasm_valkind_enum::WASM_I32 => wasm_val_inner {
                 int32_t: val.of.int32_t,
@@ -150,17 +152,33 @@ 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 ());
 }
 
-#[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;
+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));
+                }
+            },
+            _ => {}
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasm_val_delete(val: *mut wasm_val_t) {
+    if !val.is_null() {
+        unsafe {
+            std::ptr::drop_in_place(val);
+        }
     }
 }
 
@@ -173,8 +191,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 +216,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..107aa6f9f4 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.
 ///
@@ -28,7 +32,7 @@ lazy_static! {
 /// # Example
 ///
 /// See the module's documentation.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_version() -> *const c_char {
     VERSION.as_ptr() as *const _
 }
@@ -67,7 +71,7 @@ pub unsafe extern "C" fn wasmer_version() -> *const c_char {
 /// #     );
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_version_major() -> u8 {
     *VERSION_MAJOR
 }
@@ -75,7 +79,7 @@ pub unsafe extern "C" fn wasmer_version_major() -> u8 {
 /// Get the minor version of the Wasmer C API.
 ///
 /// See [`wasmer_version_major`] to learn more and get an example.  
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_version_minor() -> u8 {
     *VERSION_MINOR
 }
@@ -83,7 +87,7 @@ pub unsafe extern "C" fn wasmer_version_minor() -> u8 {
 /// Get the patch version of the Wasmer C API.
 ///
 /// See [`wasmer_version_major`] to learn more and get an example.  
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_version_patch() -> u8 {
     *VERSION_PATCH
 }
@@ -118,7 +122,7 @@ pub unsafe extern "C" fn wasmer_version_patch() -> u8 {
 /// #    .stdout(env!("CARGO_PKG_VERSION_PRE"));
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_version_pre() -> *const c_char {
     VERSION_PRE.as_ptr() as *const _
 }
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..ac0961477a 100644
--- a/lib/c-api/src/wasm_c_api/wasi/mod.rs
+++ b/lib/c-api/src/wasm_c_api/wasi/mod.rs
@@ -7,7 +7,7 @@ use super::{
     externals::{wasm_extern_t, wasm_extern_vec_t, wasm_func_t, wasm_memory_t},
     instance::wasm_instance_t,
     module::wasm_module_t,
-    store::{wasm_store_t, StoreRef},
+    store::{StoreRef, wasm_store_t},
     types::wasm_byte_vec_t,
 };
 use crate::error::update_last_error;
@@ -19,11 +19,11 @@ use std::sync::Arc;
 #[cfg(feature = "webc_runner")]
 use wasmer_api::{AsStoreMut, Imports, Module};
 use wasmer_wasix::{
+    Pipe, PluggableRuntime, WasiEnv, WasiEnvBuilder, WasiFunctionEnv, WasiVersion,
     default_fs_backing, get_wasi_version,
-    runtime::task_manager::{tokio::TokioTaskManager, InlineWaker},
+    runtime::task_manager::{block_on, tokio::TokioTaskManager},
     virtual_fs::AsyncReadExt,
     virtual_fs::VirtualFile,
-    Pipe, PluggableRuntime, WasiEnv, WasiEnvBuilder, WasiFunctionEnv, WasiVersion,
 };
 
 #[derive(Debug)]
@@ -36,13 +36,13 @@ pub struct wasi_config_t {
     runtime: Option<tokio::runtime::Runtime>,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_config_new(
     program_name: *const c_char,
 ) -> Option<Box<wasi_config_t>> {
     debug_assert!(!program_name.is_null());
 
-    let name_c_str = CStr::from_ptr(program_name);
+    let name_c_str = unsafe { CStr::from_ptr(program_name) };
     let prog_name = c_try!(name_c_str.to_str());
 
     let runtime = tokio::runtime::Builder::new_multi_thread()
@@ -60,7 +60,7 @@ pub unsafe extern "C" fn wasi_config_new(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_config_env(
     config: &mut wasi_config_t,
     key: *const c_char,
@@ -69,30 +69,30 @@ pub unsafe extern "C" fn wasi_config_env(
     debug_assert!(!key.is_null());
     debug_assert!(!value.is_null());
 
-    let key_cstr = CStr::from_ptr(key);
+    let key_cstr = unsafe { CStr::from_ptr(key) };
     let key_bytes = key_cstr.to_bytes();
-    let value_cstr = CStr::from_ptr(value);
+    let value_cstr = unsafe { CStr::from_ptr(value) };
     let value_bytes = value_cstr.to_bytes();
 
     config.builder.add_env(key_bytes, value_bytes);
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_config_arg(config: &mut wasi_config_t, arg: *const c_char) {
     debug_assert!(!arg.is_null());
 
-    let arg_cstr = CStr::from_ptr(arg);
+    let arg_cstr = unsafe { CStr::from_ptr(arg) };
     let arg_bytes = arg_cstr.to_bytes();
 
     config.builder.add_arg(arg_bytes);
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_config_preopen_dir(
     config: &mut wasi_config_t,
     dir: *const c_char,
 ) -> bool {
-    let dir_cstr = CStr::from_ptr(dir);
+    let dir_cstr = unsafe { CStr::from_ptr(dir) };
     let dir_bytes = dir_cstr.to_bytes();
     let dir_str = match std::str::from_utf8(dir_bytes) {
         Ok(dir_str) => dir_str,
@@ -110,13 +110,13 @@ pub unsafe extern "C" fn wasi_config_preopen_dir(
     true
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_config_mapdir(
     config: &mut wasi_config_t,
     alias: *const c_char,
     dir: *const c_char,
 ) -> bool {
-    let alias_cstr = CStr::from_ptr(alias);
+    let alias_cstr = unsafe { CStr::from_ptr(alias) };
     let alias_bytes = alias_cstr.to_bytes();
     let alias_str = match std::str::from_utf8(alias_bytes) {
         Ok(alias_str) => alias_str,
@@ -126,7 +126,7 @@ pub unsafe extern "C" fn wasi_config_mapdir(
         }
     };
 
-    let dir_cstr = CStr::from_ptr(dir);
+    let dir_cstr = unsafe { CStr::from_ptr(dir) };
     let dir_bytes = dir_cstr.to_bytes();
     let dir_str = match std::str::from_utf8(dir_bytes) {
         Ok(dir_str) => dir_str,
@@ -144,32 +144,32 @@ pub unsafe extern "C" fn wasi_config_mapdir(
     true
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_capture_stdout(config: &mut wasi_config_t) {
     config.inherit_stdout = false;
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_inherit_stdout(config: &mut wasi_config_t) {
     config.inherit_stdout = true;
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_capture_stderr(config: &mut wasi_config_t) {
     config.inherit_stderr = false;
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_inherit_stderr(config: &mut wasi_config_t) {
     config.inherit_stderr = true;
 }
 
-//#[no_mangle]
+//#[unsafe(no_mangle)]
 //pub extern "C" fn wasi_config_capture_stdin(config: &mut wasi_config_t) {
 //    config.inherit_stdin = false;
 //}
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_inherit_stdin(config: &mut wasi_config_t) {
     config.inherit_stdin = true;
 }
@@ -180,14 +180,14 @@ pub struct wasi_filesystem_t {
     size: usize,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_filesystem_init_static_memory(
     volume_bytes: Option<&wasm_byte_vec_t>,
 ) -> Option<Box<wasi_filesystem_t>> {
     let volume_bytes = volume_bytes.as_ref()?;
     Some(Box::new(wasi_filesystem_t {
         ptr: {
-            let ptr = (volume_bytes.data.as_ref()?) as *const _ as *const c_char;
+            let ptr = unsafe { volume_bytes.data.as_ref()? } as *const _ as *const c_char;
             if ptr.is_null() {
                 return None;
             }
@@ -197,15 +197,15 @@ pub unsafe extern "C" fn wasi_filesystem_init_static_memory(
     }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_filesystem_delete(ptr: *mut wasi_filesystem_t) {
-    let _ = Box::from_raw(ptr);
+    let _ = unsafe { Box::from_raw(ptr) };
 }
 
 /// Initializes the `imports` with an import object that links to
 /// the custom file system
 #[cfg(feature = "webc_runner")]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_env_with_filesystem(
     config: Box<wasi_config_t>,
     store: Option<&mut wasm_store_t>,
@@ -214,7 +214,7 @@ pub unsafe extern "C" fn wasi_env_with_filesystem(
     imports: Option<&mut wasm_extern_vec_t>,
     package: *const c_char,
 ) -> Option<Box<wasi_env_t>> {
-    wasi_env_with_filesystem_inner(config, store, module, fs, imports, package)
+    unsafe { wasi_env_with_filesystem_inner(config, store, module, fs, imports, package) }
 }
 
 #[cfg(feature = "webc_runner")]
@@ -228,19 +228,24 @@ unsafe fn wasi_env_with_filesystem_inner(
 ) -> Option<Box<wasi_env_t>> {
     let store = &mut store?.inner;
     let fs = fs.as_ref()?;
-    let package_str = CStr::from_ptr(package);
+    let package_str = unsafe { CStr::from_ptr(package) };
     let package = package_str.to_str().unwrap_or("");
     let module = &module.as_ref()?.inner;
     let imports = imports?;
-
-    let (wasi_env, import_object) = prepare_webc_env(
-        config,
-        &mut store.store_mut(),
-        module,
-        &*(fs.ptr as *const u8), // cast wasi_filesystem_t.ptr as &'static [u8]
-        fs.size,
-        package,
-    )?;
+    #[allow(clippy::unnecessary_cast)]
+    let fs_bytes = unsafe { &*(fs.ptr as *const u8) };
+
+    let (wasi_env, import_object) = {
+        let mut store_mut = unsafe { store.store_mut() };
+        prepare_webc_env(
+            config,
+            &mut store_mut,
+            module,
+            fs_bytes, // cast wasi_filesystem_t.ptr as &'static [u8]
+            fs.size,
+            package,
+        )?
+    };
 
     imports_set_buffer(store, module, import_object, imports)?;
 
@@ -260,6 +265,7 @@ fn prepare_webc_env(
     package_name: &str,
 ) -> Option<(WasiFunctionEnv, Imports)> {
     use virtual_fs::static_fs::StaticFileSystem;
+    use wasmer_wasix::virtual_fs::FileSystem;
     use webc::v1::{FsEntryType, WebC};
 
     let store_mut = store.as_store_mut();
@@ -275,7 +281,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()?;
@@ -286,15 +292,16 @@ fn prepare_webc_env(
                 .header
                 .top_level
                 .iter()
+                .filter(|entry| entry.fs_type == FsEntryType::Dir)
                 .cloned()
-                .filter(|e| e.fs_type == FsEntryType::Dir)
                 .map(|e| e.text.to_string())
                 .collect::<Vec<_>>()
                 .into_iter()
         })
         .collect::<Vec<_>>();
 
-    let filesystem = Box::new(StaticFileSystem::init(slice, package_name)?);
+    let filesystem =
+        Arc::new(StaticFileSystem::init(slice, package_name)?) as Arc<dyn FileSystem + Send + Sync>;
     let mut builder = config.builder.runtime(Arc::new(rt));
 
     if !config.inherit_stdout {
@@ -328,13 +335,13 @@ pub struct wasi_env_t {
 /// Create a new WASI environment.
 ///
 /// It take ownership over the `wasi_config_t`.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_env_new(
     store: Option<&mut wasm_store_t>,
     mut config: Box<wasi_config_t>,
 ) -> Option<Box<wasi_env_t>> {
     let store = &mut store?.inner;
-    let mut store_mut = store.store_mut();
+    let mut store_mut = unsafe { store.store_mut() };
 
     let runtime = config.runtime.take();
 
@@ -348,7 +355,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));
@@ -360,10 +367,12 @@ pub unsafe extern "C" fn wasi_env_new(
 
     // TODO: impl capturer for stdin
 
-    let env = c_try!(config
-        .builder
-        .runtime(Arc::new(rt))
-        .finalize(&mut store_mut));
+    let env = c_try!(
+        config
+            .builder
+            .runtime(Arc::new(rt))
+            .finalize(&mut store_mut)
+    );
 
     Some(Box::new(wasi_env_t {
         inner: env,
@@ -372,11 +381,11 @@ pub unsafe extern "C" fn wasi_env_new(
 }
 
 /// Delete a [`wasi_env_t`].
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasi_env_delete(state: Option<Box<wasi_env_t>>) {
     if let Some(mut env) = state {
-        env.inner
-            .on_exit(unsafe { &mut env.store.store_mut() }, None);
+        let mut store = unsafe { env.store.store_mut() };
+        env.inner.on_exit(&mut store, None);
     }
 }
 
@@ -384,20 +393,20 @@ pub extern "C" fn wasi_env_delete(state: Option<Box<wasi_env_t>>) {
 // NOTE: Only here to not break the C API.
 // This was previosly supported, but is no longer possible due to WASIX changes.
 // Customizing memories should be done through the builder or the runtime.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[deprecated(since = "4.0.0")]
 pub unsafe extern "C" fn wasi_env_set_memory(_env: &mut wasi_env_t, _memory: &wasm_memory_t) {
     panic!("wasmer_env_set_memory() is not supported");
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_env_read_stdout(
     env: &mut wasi_env_t,
     buffer: *mut c_char,
     buffer_len: usize,
 ) -> isize {
-    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
-    let store = env.store.store();
+    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
+    let store = unsafe { env.store.store() };
 
     let stdout = {
         let data = env.inner.data(&store);
@@ -417,14 +426,14 @@ pub unsafe extern "C" fn wasi_env_read_stdout(
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_env_read_stderr(
     env: &mut wasi_env_t,
     buffer: *mut c_char,
     buffer_len: usize,
 ) -> isize {
-    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
-    let store = env.store.store();
+    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
+    let store = unsafe { env.store.store() };
     let stderr = {
         let data = env.inner.data(&store);
         data.stderr()
@@ -446,11 +455,11 @@ fn read_inner(
     wasi_file: &mut Box<dyn VirtualFile + Send + Sync + 'static>,
     inner_buffer: &mut [u8],
 ) -> isize {
-    InlineWaker::block_on(async {
+    block_on(async {
         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
             }
         }
@@ -518,7 +527,7 @@ impl TryFrom<wasi_version_t> for WasiVersion {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_get_wasi_version(module: &wasm_module_t) -> wasi_version_t {
     get_wasi_version(&module.inner, false)
         .map(Into::into)
@@ -527,14 +536,14 @@ pub unsafe extern "C" fn wasi_get_wasi_version(module: &wasm_module_t) -> wasi_v
 
 /// Non-standard function to get the imports needed for the WASI
 /// implementation ordered as expected by the `wasm_module_t`.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_get_imports(
     _store: Option<&wasm_store_t>,
     wasi_env: Option<&mut wasi_env_t>,
     module: Option<&wasm_module_t>,
     imports: &mut wasm_extern_vec_t,
 ) -> bool {
-    wasi_get_imports_inner(wasi_env, module, imports).is_some()
+    unsafe { wasi_get_imports_inner(wasi_env, module, imports) }.is_some()
 }
 
 unsafe fn wasi_get_imports_inner(
@@ -546,26 +555,31 @@ unsafe fn wasi_get_imports_inner(
     let store = &mut wasi_env.store;
     let module = module?;
 
-    let mut import_object = c_try!(wasi_env
-        .inner
-        .import_object(&mut store.store_mut(), &module.inner));
+    let mut import_object = {
+        let mut store_mut = unsafe { store.store_mut() };
+        c_try!(wasi_env.inner.import_object(&mut store_mut, &module.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
-        .inner
-        .data(&store.store())
-        .runtime
-        .task_manager()
-        .clone();
-    let memory = tasks
-        .build_memory(&mut store.store_mut(), spawn_type)
-        .unwrap();
+    let tasks = {
+        let store_ref = unsafe { store.store() };
+        wasi_env
+            .inner
+            .data(&store_ref)
+            .runtime
+            .task_manager()
+            .clone()
+    };
+    let memory = {
+        let mut store_mut = unsafe { store.store_mut() };
+        tasks.build_memory(&mut store_mut, &spawn_type).unwrap()
+    };
 
     if let Some(memory) = memory {
         import_object.define("env", "memory", memory);
@@ -582,40 +596,43 @@ pub(crate) fn imports_set_buffer(
     import_object: wasmer_api::Imports,
     imports: &mut wasm_extern_vec_t,
 ) -> Option<()> {
-    imports.set_buffer(c_try!(module
-        .imports()
-        .map(|import_type| {
-            let ext = import_object
-                .get_export(import_type.module(), import_type.name())
-                .ok_or_else(|| {
-                    format!(
-                        "Failed to resolve import \"{}\" \"{}\"",
-                        import_type.module(),
-                        import_type.name()
-                    )
-                })?;
-
-            Ok(Some(Box::new(wasm_extern_t::new(store.clone(), ext))))
-        })
-        .collect::<Result<Vec<_>, String>>()));
+    imports.set_buffer(c_try!(
+        module
+            .imports()
+            .map(|import_type| {
+                let ext = import_object
+                    .get_export(import_type.module(), import_type.name())
+                    .ok_or_else(|| {
+                        format!(
+                            "Failed to resolve import \"{}\" \"{}\"",
+                            import_type.module(),
+                            import_type.name()
+                        )
+                    })?;
+
+                Ok(Some(Box::new(wasm_extern_t::new(store.clone(), ext))))
+            })
+            .collect::<Result<Vec<_>, String>>()
+    ));
 
     Some(())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_env_initialize_instance(
     wasi_env: &mut wasi_env_t,
     store: &mut wasm_store_t,
     instance: &mut wasm_instance_t,
 ) -> bool {
+    let mut store_mut = unsafe { store.inner.store_mut() };
     wasi_env
         .inner
-        .initialize(&mut store.inner.store_mut(), instance.inner.clone())
+        .initialize(&mut store_mut, instance.inner.clone())
         .unwrap();
     true
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasi_get_start_function(
     instance: &mut wasm_instance_t,
 ) -> Option<Box<wasm_func_t>> {
@@ -633,7 +650,11 @@ mod tests {
     #[cfg(target_os = "windows")]
     use wasmer_inline_c::assert_c;
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_wasi_get_wasi_version_snapshot0() {
         (assert_c! {
@@ -667,7 +688,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_wasi_get_wasi_version_snapshot1() {
         (assert_c! {
@@ -701,7 +726,11 @@ mod tests {
         .success();
     }
 
-    #[cfg_attr(coverage, ignore)]
+    #[allow(
+        unexpected_cfgs,
+        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
+    )]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     #[test]
     fn test_wasi_get_wasi_version_invalid() {
         (assert_c! {
diff --git a/lib/c-api/src/wasm_c_api/wat.rs b/lib/c-api/src/wasm_c_api/wat.rs
index 4d0c3928c6..ee44b0ae62 100644
--- a/lib/c-api/src/wasm_c_api/wat.rs
+++ b/lib/c-api/src/wasm_c_api/wat.rs
@@ -12,7 +12,7 @@ use super::types::wasm_byte_vec_t;
 /// # Safety
 /// This function is unsafe in order to be callable from C.
 #[cfg(feature = "wat")]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wat2wasm(wat: &wasm_byte_vec_t, out: &mut wasm_byte_vec_t) {
     match wasmer_api::wat2wasm(wat.as_slice()) {
         Ok(val) => out.set_buffer(val.into_owned()),
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..585f66f705 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,12 +1,12 @@
 [package]
 name = "wasmer-c-api-test-runner"
-version = "4.3.7"
-edition = "2021"
-license = "MIT"
 description = "wasmer-c-api-test-runner"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
 
 [dependencies]
-cc = "1.0"
-target-lexicon = "0.11"
-regex = "1.6"
-walkdir = "2.3.2"
\ No newline at end of file
+cc.workspace = true
+target-lexicon.workspace = true
+regex.workspace = true
+walkdir.workspace = true
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..15e1038b6f 100644
--- a/lib/cache/Cargo.toml
+++ b/lib/cache/Cargo.toml
@@ -13,21 +13,21 @@ 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 = "=7.0.0", default-features = false }
+hex.workspace = true
+thiserror.workspace = true
+blake3.workspace = true
 
 [dev-dependencies]
-criterion = { version = "0.5", default-features = false }
-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"
-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" }
+criterion = { workspace = true, default-features = false }
+clap = { workspace = true, default-features = true }
+clap_builder.workspace = true
+clap_derive.workspace = true
+clap_lex.workspace = true
+tempfile.workspace = true
+rand.workspace = true
+wasmer = { path = "../api", version = "=7.0.0", default-features = false, features = ["sys", "cranelift"] }
+wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=7.0.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", "wasmer/cranelift"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/cache/benches/bench_filesystem_cache.rs b/lib/cache/benches/bench_filesystem_cache.rs
index 8153e7c7b3..00897ca603 100644
--- a/lib/cache/benches/bench_filesystem_cache.rs
+++ b/lib/cache/benches/bench_filesystem_cache.rs
@@ -1,7 +1,7 @@
 #![allow(unused_imports)]
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use rand::distributions::Alphanumeric;
-use rand::{thread_rng, Rng};
+use criterion::{Criterion, criterion_group, criterion_main};
+use rand::distr::Alphanumeric;
+use rand::{Rng, rng};
 use tempfile::TempDir;
 use wasmer::{Module, Store};
 use wasmer_cache::Cache;
@@ -9,7 +9,7 @@ use wasmer_cache::{FileSystemCache, Hash};
 use wasmer_compiler_singlepass::Singlepass;
 
 fn random_key() -> Hash {
-    Hash::new(rand::thread_rng().gen::<[u8; 32]>())
+    Hash::new(rand::rng().random::<[u8; 32]>())
 }
 
 pub fn store_cache_universal(c: &mut Criterion) {
diff --git a/lib/cache/src/filesystem.rs b/lib/cache/src/filesystem.rs
index 2efd11301f..0786bf480e 100644
--- a/lib/cache/src/filesystem.rs
+++ b/lib/cache/src/filesystem.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(not(feature = "filesystem"), allow(unused))]
 use crate::cache::Cache;
 use crate::hash::Hash;
-use std::fs::{create_dir_all, File};
+use std::fs::{File, create_dir_all};
 use std::io::{self, Write};
 use std::path::PathBuf;
 use wasmer::{AsEngineRef, DeserializeError, Module, SerializeError};
@@ -68,10 +68,10 @@ impl FileSystemCache {
             // Create the directory and any parent directories if they don't yet exist.
             let res = create_dir_all(&path);
             if res.is_err() {
-                Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("failed to create cache directory: {}", path.display()),
-                ))
+                Err(io::Error::other(format!(
+                    "failed to create cache directory: {}",
+                    path.display()
+                )))
             } else {
                 Ok(Self { path, ext: None })
             }
@@ -98,12 +98,12 @@ 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()
         };
         let path = self.path.join(filename);
-        let ret = Module::deserialize_from_file(engine, path.clone());
+        let ret = unsafe { Module::deserialize_from_file(engine, path.clone()) };
         if ret.is_err() {
             // If an error occurs while deserializing then we can not trust it anymore
             // so delete the cache file
@@ -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/cache/src/lib.rs b/lib/cache/src/lib.rs
index d988a65c4e..5e19b97522 100644
--- a/lib/cache/src/lib.rs
+++ b/lib/cache/src/lib.rs
@@ -13,7 +13,7 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod cache;
 mod filesystem;
diff --git a/lib/cli-compiler/Cargo.toml b/lib/cli-compiler/Cargo.toml
deleted file mode 100644
index 0065dc0703..0000000000
--- a/lib/cli-compiler/Cargo.toml
+++ /dev/null
@@ -1,83 +0,0 @@
-[package]
-name = "wasmer-compiler-cli"
-description = "Wasmer Compiler CLI"
-categories = ["wasm", "command-line-interface"]
-keywords = ["wasm", "webassembly", "cli"]
-readme = "README.md"
-default-run = "wasmer-compiler"
-build = "build.rs"
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[[bin]]
-name = "wasmer-compiler"
-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" }
-is-terminal = "0.4.7"
-colored = "2.0"
-anyhow = "1.0"
-# For the function names autosuggestion
-distance = "0.4"
-# For the inspect subcommand
-bytesize = "1.0"
-cfg-if = "1.0"
-# For debug feature
-fern = { version = "0.6", features = ["colored"], optional = true }
-log = { version = "0.4", optional = true }
-target-lexicon = { version = "0.12", 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"] }
-
-[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"] }
-# 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",
-]}
-
-[target.'cfg(target_os = "linux")'.dependencies]
-unix_mode = "0.1.3"
-
-[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 = []
-engine = []
-compiler = [
-    "wasmer-compiler/translator",
-    "wasmer-compiler/compiler",
-]
-singlepass = [
-    "wasmer-compiler-singlepass",
-    "compiler",
-]
-cranelift = [
-    "wasmer-compiler-cranelift",
-    "compiler",
-]
-debug = ["fern", "log"]
-disable-all-logging = []
-jit = []
-
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/cli-compiler/README.md b/lib/cli-compiler/README.md
deleted file mode 100644
index 5fb713d090..0000000000
--- a/lib/cli-compiler/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# `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)
-
-This crate is the Wasmer Compiler only CLI.
-
-
-## Features
-
-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
-
-Once you have Wasmer installed, you can start executing WebAssembly files easily:
-
-Get the current Wasmer version:
-
-```bash
-wasmer-compiler -V
-```
-
-Compile a WebAssembly file:
-
-```bash
-wasmer-compiler compile myfile.wasm -o myfile.wasmu --singlepass
-```
diff --git a/lib/cli-compiler/build.rs b/lib/cli-compiler/build.rs
deleted file mode 100644
index 36fe64763e..0000000000
--- a/lib/cli-compiler/build.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-env-changed=WASMER_INSTALL_PREFIX");
-}
diff --git a/lib/cli-compiler/src/bin/wasmer_compiler.rs b/lib/cli-compiler/src/bin/wasmer_compiler.rs
deleted file mode 100644
index ba0f2e10f5..0000000000
--- a/lib/cli-compiler/src/bin/wasmer_compiler.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-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/cli.rs b/lib/cli-compiler/src/cli.rs
deleted file mode 100644
index c67e2df89f..0000000000
--- a/lib/cli-compiler/src/cli.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! The logic for the Wasmer CLI tool.
-
-use crate::commands::Compile;
-use crate::commands::{Config, Validate};
-use crate::error::PrettyError;
-use anyhow::Result;
-
-use clap::{error::ErrorKind, Parser};
-
-#[derive(Parser)]
-#[clap(
-    name = "wasmer-compiler",
-    about = "WebAssembly standalone Compiler.",
-    author
-)]
-/// The options for the wasmer Command Line Interface
-enum WasmerCLIOptions {
-    /// Validate a WebAssembly binary
-    #[clap(name = "validate")]
-    Validate(Validate),
-
-    /// Compile a WebAssembly binary
-    #[clap(name = "compile")]
-    Compile(Compile),
-
-    /// Get various configuration information needed
-    /// to compile programs which use Wasmer
-    #[clap(name = "config")]
-    Config(Config),
-}
-
-impl WasmerCLIOptions {
-    fn execute(&self) -> Result<()> {
-        match self {
-            Self::Validate(validate) => validate.execute(),
-            Self::Compile(compile) => compile.execute(),
-            Self::Config(config) => config.execute(),
-        }
-    }
-}
-
-/// The main function for the Wasmer CLI tool.
-pub fn wasmer_main() {
-    // We allow windows to print properly colors
-    #[cfg(windows)]
-    colored::control::set_virtual_terminal(true).unwrap();
-
-    // We try to run wasmer with the normal arguments.
-    // Eg. `wasmer <SUBCOMMAND>`
-    // In case that fails, we fallback trying the Run subcommand directly.
-    // Eg. `wasmer myfile.wasm --dir=.`
-    //
-    // In case we've been run as wasmer-binfmt-interpreter myfile.wasm args,
-    // we assume that we're registered via binfmt_misc
-    let args = std::env::args().collect::<Vec<_>>();
-    let command = args.get(1);
-    let options = {
-        match command.unwrap_or(&"".to_string()).as_ref() {
-            "compile" | "config" | "help" | "inspect" | "validate" => WasmerCLIOptions::parse(),
-            _ => {
-                WasmerCLIOptions::try_parse_from(args.iter()).unwrap_or_else(|e| {
-                    match e.kind() {
-                        // This fixes a issue that:
-                        // 1. Shows the version twice when doing `wasmer -V`
-                        // 2. Shows the run help (instead of normal help) when doing `wasmer --help`
-                        ErrorKind::DisplayVersion | ErrorKind::DisplayHelp => e.exit(),
-                        _ => WasmerCLIOptions::Compile(Compile::parse()),
-                    }
-                })
-            }
-        }
-    };
-
-    PrettyError::report(options.execute());
-}
diff --git a/lib/cli-compiler/src/commands.rs b/lib/cli-compiler/src/commands.rs
deleted file mode 100644
index 74418834fa..0000000000
--- a/lib/cli-compiler/src/commands.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! The commands available in the Wasmer binary.
-mod compile;
-mod config;
-mod validate;
-
-pub use compile::*;
-pub use {config::*, validate::*};
diff --git a/lib/cli-compiler/src/commands/compile.rs b/lib/cli-compiler/src/commands/compile.rs
deleted file mode 100644
index 7a5147066b..0000000000
--- a/lib/cli-compiler/src/commands/compile.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use crate::store::StoreOptions;
-use crate::warning;
-use anyhow::{Context, Result};
-use clap::Parser;
-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,
-};
-
-#[derive(Debug, Parser)]
-/// The options for the `wasmer compile` subcommand
-pub struct Compile {
-    /// Input file
-    #[clap(name = "FILE")]
-    path: PathBuf,
-
-    /// Output file
-    #[clap(name = "OUTPUT PATH", short = 'o')]
-    output: PathBuf,
-
-    /// Compilation Target triple
-    #[clap(long = "target")]
-    target_triple: Option<Triple>,
-
-    #[clap(flatten)]
-    store: StoreOptions,
-
-    #[clap(short = 'm')]
-    cpu_features: Vec<CpuFeature>,
-}
-
-impl Compile {
-    /// Runs logic for the `compile` subcommand
-    pub fn execute(&self) -> Result<()> {
-        self.inner_execute()
-            .context(format!("failed to compile `{}`", self.path.display()))
-    }
-
-    fn inner_execute(&self) -> Result<()> {
-        let target = self
-            .target_triple
-            .as_ref()
-            .map(|target_triple| {
-                let mut features = self
-                    .cpu_features
-                    .clone()
-                    .into_iter()
-                    .fold(CpuFeature::set(), |a, b| a | b);
-                // Cranelift requires SSE2, so we have this "hack" for now to facilitate
-                // usage
-                if target_triple.architecture == Architecture::X86_64 {
-                    features |= CpuFeature::SSE2;
-                }
-                Target::new(target_triple.clone(), features)
-            })
-            .unwrap_or_default();
-        let (engine_builder, compiler_type) = self.store.get_engine_for_target(target.clone())?;
-        let engine = engine_builder
-            .set_hash_algorithm(Some(wasmer_types::HashAlgorithm::Sha256))
-            .engine();
-        let output_filename = self
-            .output
-            .file_stem()
-            .map(|osstr| osstr.to_string_lossy().to_string())
-            .unwrap_or_default();
-        // `.wasmu` is the default extension for all the triples. It
-        // stands for “Wasm Universal”.
-        let recommended_extension = "wasmu";
-        match self.output.extension() {
-            Some(ext) => {
-                if ext != recommended_extension {
-                    warning!("the output file has a wrong extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
-                }
-            }
-            None => {
-                warning!("the output file has no extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
-            }
-        }
-        let tunables = self.store.get_tunables_for_target(&target)?;
-
-        println!("Compiler: {}", compiler_type.to_string());
-        println!("Target: {}", target.triple());
-
-        // compile and save the artifact (without using module from api)
-        let path: &Path = self.path.as_ref();
-        let wasm_bytes = std::fs::read(path)?;
-        let environ = ModuleEnvironment::new();
-        let translation = environ.translate(&wasm_bytes).map_err(CompileError::Wasm)?;
-        let module = translation.module;
-        let memory_styles: PrimaryMap<MemoryIndex, MemoryStyle> = module
-            .memories
-            .values()
-            .map(|memory_type| tunables.memory_style(memory_type))
-            .collect();
-        let table_styles: PrimaryMap<TableIndex, TableStyle> = module
-            .tables
-            .values()
-            .map(|table_type| tunables.table_style(table_type))
-            .collect();
-        let artifact = ArtifactBuild::new(
-            &mut engine.inner_mut(),
-            &wasm_bytes,
-            &target,
-            memory_styles,
-            table_styles,
-            engine.hash_algorithm(),
-        )?;
-        let serialized = artifact.serialize()?;
-        fs::write(output_filename, serialized)?;
-        eprintln!(
-            "✔ File compiled successfully to `{}`.",
-            self.output.display(),
-        );
-
-        Ok(())
-    }
-}
diff --git a/lib/cli-compiler/src/commands/config.rs b/lib/cli-compiler/src/commands/config.rs
deleted file mode 100644
index 155fb0c1dd..0000000000
--- a/lib/cli-compiler/src/commands/config.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use crate::VERSION;
-use anyhow::{Context, Result};
-use clap::Parser;
-use std::env;
-use std::path::PathBuf;
-
-#[derive(Debug, Parser)]
-/// The options for the `wasmer config` subcommand
-pub struct Config {
-    /// Print the installation prefix.
-    #[clap(long, conflicts_with = "pkg_config")]
-    prefix: bool,
-
-    /// Directory containing Wasmer executables.
-    #[clap(long, conflicts_with = "pkg_config")]
-    bindir: bool,
-
-    /// Directory containing Wasmer headers.
-    #[clap(long, conflicts_with = "pkg_config")]
-    includedir: bool,
-
-    /// Directory containing Wasmer libraries.
-    #[clap(long, conflicts_with = "pkg_config")]
-    libdir: bool,
-
-    /// Libraries needed to link against Wasmer components.
-    #[clap(long, conflicts_with = "pkg_config")]
-    libs: bool,
-
-    /// C compiler flags for files that include Wasmer headers.
-    #[clap(long, conflicts_with = "pkg_config")]
-    cflags: bool,
-
-    /// It outputs the necessary details for compiling
-    /// and linking a program to Wasmer, using the `pkg-config` format.
-    #[clap(long)]
-    pkg_config: bool,
-}
-
-impl Config {
-    /// Runs logic for the `config` subcommand
-    pub fn execute(&self) -> Result<()> {
-        self.inner_execute()
-            .context("failed to retrieve the wasmer config".to_string())
-    }
-    fn inner_execute(&self) -> Result<()> {
-        let key = "WASMER_DIR";
-        let wasmer_dir = env::var(key)
-            .ok()
-            .or_else(|| option_env!("WASMER_INSTALL_PREFIX").map(str::to_string))
-            .or_else(|| {
-                // Allowing deprecated function home_dir since it works fine,
-                // and will never be removed from std.
-                #[allow(deprecated)]
-                let dir = std::env::home_dir()?.join(".wasmer").to_str()?.to_string();
-
-                Some(dir)
-            })
-            .context(format!(
-                "failed to retrieve the {} environment variables",
-                key
-            ))?;
-
-        let prefix = PathBuf::from(wasmer_dir);
-
-        let prefixdir = prefix.display().to_string();
-        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);
-
-        if self.pkg_config {
-            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);
-            return Ok(());
-        }
-
-        if self.prefix {
-            println!("{}", prefixdir);
-        }
-        if self.bindir {
-            println!("{}", bindir);
-        }
-        if self.includedir {
-            println!("{}", includedir);
-        }
-        if self.libdir {
-            println!("{}", libdir);
-        }
-        if self.libs {
-            println!("{}", libs);
-        }
-        if self.cflags {
-            println!("{}", cflags);
-        }
-        Ok(())
-    }
-}
diff --git a/lib/cli-compiler/src/commands/validate.rs b/lib/cli-compiler/src/commands/validate.rs
deleted file mode 100644
index c3c421f466..0000000000
--- a/lib/cli-compiler/src/commands/validate.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use crate::store::StoreOptions;
-use anyhow::{bail, Context, Result};
-use clap::Parser;
-use std::path::PathBuf;
-use std::str::FromStr;
-use wasmer_types::{is_wasm, CpuFeature, Target, Triple};
-
-#[derive(Debug, Parser)]
-/// The options for the `wasmer validate` subcommand
-pub struct Validate {
-    /// File to validate as WebAssembly
-    #[clap(name = "FILE")]
-    path: PathBuf,
-
-    #[clap(flatten)]
-    store: StoreOptions,
-}
-
-impl Validate {
-    /// Runs logic for the `validate` subcommand
-    pub fn execute(&self) -> Result<()> {
-        self.inner_execute()
-            .context(format!("failed to validate `{}`", self.path.display()))
-    }
-    fn inner_execute(&self) -> Result<()> {
-        let target = Target::new(
-            Triple::from_str("x86_64-linux-gnu").unwrap(),
-            CpuFeature::SSE2 | CpuFeature::AVX,
-        );
-        let (engine_builder, _compiler_type) = self.store.get_engine_for_target(target)?;
-        let engine = engine_builder.engine();
-        let module_contents = std::fs::read(&self.path)?;
-        if !is_wasm(&module_contents) {
-            bail!("`wasmer validate` only validates WebAssembly files");
-        }
-        engine.validate(&module_contents)?;
-        eprintln!("Validation passed for `{}`.", self.path.display());
-        Ok(())
-    }
-}
diff --git a/lib/cli-compiler/src/common.rs b/lib/cli-compiler/src/common.rs
deleted file mode 100644
index 81af03197c..0000000000
--- a/lib/cli-compiler/src/common.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! Common module with common used structures across different
-//! commands.
-use crate::VERSION;
-use clap::Parser;
-use std::env;
-use std::path::PathBuf;
-
-#[derive(Debug, 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,
-
-    /// Enable support for the threads proposal.
-    #[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,
-}
-
-/// Get the cache dir
-pub fn get_cache_dir() -> PathBuf {
-    match env::var("WASMER_CACHE_DIR") {
-        Ok(dir) => {
-            let mut path = PathBuf::from(dir);
-            path.push(VERSION);
-            path
-        }
-        Err(_) => {
-            // We use a temporal directory for saving cache files
-            let mut temp_dir = env::temp_dir();
-            temp_dir.push("wasmer");
-            temp_dir.push(VERSION);
-            temp_dir
-        }
-    }
-}
diff --git a/lib/cli-compiler/src/error.rs b/lib/cli-compiler/src/error.rs
deleted file mode 100644
index f23b50339c..0000000000
--- a/lib/cli-compiler/src/error.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-//! Implements `PretyError` to print pretty errors in the CLI (when they happen)
-
-use anyhow::{Chain, Error};
-use colored::*;
-use std::fmt::{self, Debug, Write};
-
-/// A `PrettyError` for printing `anyhow::Error` nicely.
-pub struct PrettyError {
-    error: Error,
-}
-
-/// A macro that prints a warning with nice colors
-#[macro_export]
-macro_rules! warning {
-    ($($arg:tt)*) => ({
-        use colored::*;
-        eprintln!("{}: {}", "warning".yellow().bold(), format!($($arg)*));
-    })
-}
-
-impl PrettyError {
-    /// Process a `Result` printing any errors and exiting
-    /// the process after
-    pub fn report<T>(result: Result<T, Error>) -> ! {
-        std::process::exit(match result {
-            Ok(_t) => 0,
-            Err(error) => {
-                eprintln!("{:?}", PrettyError { error });
-                1
-            }
-        });
-    }
-}
-
-impl Debug for PrettyError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let error = &self.error;
-
-        if f.alternate() {
-            return Debug::fmt(&error, f);
-        }
-
-        write!(f, "{}", format!("{}: {}", "error".red(), error).bold())?;
-        // write!(f, "{}", error)?;
-
-        if let Some(cause) = error.source() {
-            // write!(f, "\n{}:", "caused by".bold().blue())?;
-            let chain = Chain::new(cause);
-            let (total_errors, _) = chain.size_hint();
-            for (n, error) in chain.enumerate() {
-                writeln!(f)?;
-                let mut indented = Indented {
-                    inner: f,
-                    number: Some(n + 1),
-                    is_last: n == total_errors - 1,
-                    started: false,
-                };
-                write!(indented, "{}", error)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-struct Indented<'a, D> {
-    inner: &'a mut D,
-    number: Option<usize>,
-    started: bool,
-    is_last: bool,
-}
-
-impl<T> Write for Indented<'_, T>
-where
-    T: Write,
-{
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for (i, line) in s.split('\n').enumerate() {
-            if !self.started {
-                self.started = true;
-                match self.number {
-                    Some(number) => {
-                        if !self.is_last {
-                            write!(
-                                self.inner,
-                                "{} {: >4} ",
-                                "│".bold().blue(),
-                                format!("{}:", number).dimmed()
-                            )?
-                        } else {
-                            write!(
-                                self.inner,
-                                "{}{: >2}: ",
-                                "╰─▶".bold().blue(),
-                                format!("{}", number).bold().blue()
-                            )?
-                        }
-                    }
-                    None => self.inner.write_str("    ")?,
-                }
-            } else if i > 0 {
-                self.inner.write_char('\n')?;
-                if self.number.is_some() {
-                    self.inner.write_str("       ")?;
-                } else {
-                    self.inner.write_str("    ")?;
-                }
-            }
-
-            self.inner.write_str(line)?;
-        }
-
-        Ok(())
-    }
-}
diff --git a/lib/cli-compiler/src/lib.rs b/lib/cli-compiler/src/lib.rs
deleted file mode 100644
index 7ee91dacca..0000000000
--- a/lib/cli-compiler/src/lib.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! The Wasmer binary lib
-
-#![deny(
-    missing_docs,
-    dead_code,
-    nonstandard_style,
-    unused_mut,
-    unused_variables,
-    unused_unsafe,
-    unreachable_patterns
-)]
-#![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 anyhow;
-
-pub mod commands;
-pub mod common;
-#[macro_use]
-pub mod error;
-pub mod cli;
-#[cfg(feature = "debug")]
-pub mod logging;
-pub mod store;
-pub mod utils;
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/lib/cli-compiler/src/logging.rs b/lib/cli-compiler/src/logging.rs
deleted file mode 100644
index 88ae282d80..0000000000
--- a/lib/cli-compiler/src/logging.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Logging functions for the debug feature.
-
-use anyhow::Result;
-use fern::colors::{Color, ColoredLevelConfig};
-use std::time;
-
-/// The debug level
-pub type DebugLevel = log::LevelFilter;
-
-/// Subroutine to instantiate the loggers
-pub fn set_up_logging(verbose: u8) -> Result<(), String> {
-    let colors_line = ColoredLevelConfig::new()
-        .error(Color::Red)
-        .warn(Color::Yellow)
-        .trace(Color::BrightBlack);
-    let should_color = crate::utils::wasmer_should_print_color();
-
-    let colors_level = colors_line.info(Color::Green);
-    let level = match verbose {
-        1 => DebugLevel::Debug,
-        _ => DebugLevel::Trace,
-    };
-    let dispatch = fern::Dispatch::new()
-        .level(level)
-        .chain({
-            let base = if should_color {
-                fern::Dispatch::new().format(move |out, message, record| {
-                    let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH).expect("Can't get time");
-                    out.finish(format_args!(
-                        "{color_line}[{seconds}.{millis} {level} {target}{color_line}]{ansi_close} {message}",
-                        color_line = format_args!(
-                            "\x1B[{}m",
-                            colors_line.get_color(&record.level()).to_fg_str()
-                        ),
-                        seconds = time.as_secs(),
-                        millis = time.subsec_millis(),
-                        level = colors_level.color(record.level()),
-                        target = record.target(),
-                        ansi_close = "\x1B[0m",
-                        message = message,
-                    ));
-                })
-            } else {
-                // default formatter without color
-                fern::Dispatch::new().format(move |out, message, record| {
-                    let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH).expect("Can't get time");
-                    out.finish(format_args!(
-                        "[{seconds}.{millis} {level} {target}] {message}",
-                        seconds = time.as_secs(),
-                        millis = time.subsec_millis(),
-                        level = record.level(),
-                        target = record.target(),
-                        message = message,
-                    ));
-                })
-            };
-
-            base
-                .filter(|metadata| {
-                    metadata.target().starts_with("wasmer")
-                })
-                .chain(std::io::stdout())
-        });
-
-    dispatch.apply().map_err(|e| format!("{}", e))?;
-
-    Ok(())
-}
diff --git a/lib/cli-compiler/src/store.rs b/lib/cli-compiler/src/store.rs
deleted file mode 100644
index 370d59b535..0000000000
--- a/lib/cli-compiler/src/store.rs
+++ /dev/null
@@ -1,383 +0,0 @@
-//! Common module with common used structures across different
-//! commands.
-
-use crate::common::WasmFeatures;
-use anyhow::Result;
-use clap::Parser;
-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};
-
-/// Minimul Subset of Tunable parameters for WebAssembly compilation.
-#[derive(Clone)]
-pub struct SubsetTunables {
-    /// For static heaps, the size in wasm pages of the heap protected by bounds checking.
-    pub static_memory_bound: Pages,
-
-    /// The size in bytes of the offset guard for static heaps.
-    pub static_memory_offset_guard_size: u64,
-
-    /// The size in bytes of the offset guard for dynamic heaps.
-    pub dynamic_memory_offset_guard_size: u64,
-}
-
-impl SubsetTunables {
-    /// Get the `BaseTunables` for a specific Target
-    pub fn for_target(target: &Target) -> Self {
-        let triple = target.triple();
-        let pointer_width: PointerWidth = triple.pointer_width().unwrap();
-        let (static_memory_bound, static_memory_offset_guard_size): (Pages, u64) =
-            match pointer_width {
-                PointerWidth::U16 => (0x400.into(), 0x1000),
-                PointerWidth::U32 => (0x4000.into(), 0x1_0000),
-                // Static Memory Bound:
-                //   Allocating 4 GiB of address space let us avoid the
-                //   need for explicit bounds checks.
-                // Static Memory Guard size:
-                //   Allocating 2 GiB of address space lets us translate wasm
-                //   offsets into x86 offsets as aggressively as we can.
-                PointerWidth::U64 => (0x1_0000.into(), 0x8000_0000),
-            };
-
-        // Allocate a small guard to optimize common cases but without
-        // wasting too much memory.
-        // The Windows memory manager seems more laxed than the other ones
-        // And a guard of just 1 page may not be enough is some borderline cases
-        // So using 2 pages for guard on this platform
-        #[cfg(target_os = "windows")]
-        let dynamic_memory_offset_guard_size: u64 = 0x2_0000;
-        #[cfg(not(target_os = "windows"))]
-        let dynamic_memory_offset_guard_size: u64 = 0x1_0000;
-
-        Self {
-            static_memory_bound,
-            static_memory_offset_guard_size,
-            dynamic_memory_offset_guard_size,
-        }
-    }
-    /// Get a `MemoryStyle` for the provided `MemoryType`
-    pub fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
-        // A heap with a maximum that doesn't exceed the static memory bound specified by the
-        // tunables make it static.
-        //
-        // If the module doesn't declare an explicit maximum treat it as 4GiB.
-        let maximum = memory.maximum.unwrap_or_else(Pages::max_value);
-        if maximum <= self.static_memory_bound {
-            MemoryStyle::Static {
-                // Bound can be larger than the maximum for performance reasons
-                bound: self.static_memory_bound,
-                offset_guard_size: self.static_memory_offset_guard_size,
-            }
-        } else {
-            MemoryStyle::Dynamic {
-                offset_guard_size: self.dynamic_memory_offset_guard_size,
-            }
-        }
-    }
-
-    /// Get a [`TableStyle`] for the provided [`TableType`].
-    pub fn table_style(&self, _table: &TableType) -> TableStyle {
-        TableStyle::CallerChecksSignature
-    }
-}
-
-#[derive(Debug, Clone, Parser, Default)]
-/// The compiler and engine options
-pub struct StoreOptions {
-    #[clap(flatten)]
-    compiler: CompilerOptions,
-}
-
-#[derive(Debug, Clone, 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.
-    #[allow(unused)]
-    #[clap(long)]
-    #[allow(dead_code)]
-    enable_verifier: bool,
-
-    /// LLVM debug directory, where IR and object files will be written to.
-    #[allow(unused)]
-    #[cfg(feature = "llvm")]
-    #[cfg_attr(feature = "llvm", clap(long, parse(from_os_str)))]
-    llvm_debug_dir: Option<PathBuf>,
-
-    #[clap(flatten)]
-    features: WasmFeatures,
-}
-
-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.threads || self.features.all {
-            features.threads(true);
-        }
-        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)
-    }
-
-    fn get_engine_by_type(
-        &self,
-        target: Target,
-        compiler_config: Box<dyn CompilerConfig>,
-    ) -> Result<EngineBuilder> {
-        let features = self.get_features(compiler_config.default_features_for_target(&target))?;
-        let engine: EngineBuilder = EngineBuilder::new(compiler_config)
-            .set_target(Some(target))
-            .set_features(Some(features));
-
-        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;
-                use std::fs::File;
-                use std::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)]
-pub enum CompilerType {
-    /// Singlepass compiler
-    Singlepass,
-    /// Cranelift compiler
-    Cranelift,
-    /// LLVM compiler
-    LLVM,
-    /// Headless compiler
-    #[allow(dead_code)]
-    Headless,
-}
-
-impl CompilerType {
-    /// Return all enabled compilers
-    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(),
-        }
-    }
-}
-
-impl StoreOptions {
-    /// Get a EngineBulder for the Target
-    pub fn get_engine_for_target(&self, target: Target) -> Result<(EngineBuilder, CompilerType)> {
-        let (compiler_config, compiler_type) = self.compiler.get_compiler_config()?;
-        let engine = self.get_engine_with_compiler(target, compiler_config)?;
-        Ok((engine, compiler_type))
-    }
-
-    fn get_engine_with_compiler(
-        &self,
-        target: Target,
-        compiler_config: Box<dyn CompilerConfig>,
-    ) -> Result<EngineBuilder> {
-        self.compiler.get_engine_by_type(target, compiler_config)
-    }
-
-    /// Get (Subset)Tunables for the Target
-    pub fn get_tunables_for_target(&self, target: &Target) -> Result<SubsetTunables> {
-        let tunables = SubsetTunables::for_target(target);
-        Ok(tunables)
-    }
-}
diff --git a/lib/cli-compiler/src/utils.rs b/lib/cli-compiler/src/utils.rs
deleted file mode 100644
index 7a4a925460..0000000000
--- a/lib/cli-compiler/src/utils.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! Utility functions for the WebAssembly module
-use anyhow::{bail, Context, Result};
-use is_terminal::IsTerminal;
-use std::path::PathBuf;
-use std::{env, path::Path};
-
-/// Whether or not Wasmer should print with color
-pub fn wasmer_should_print_color() -> bool {
-    env::var("WASMER_COLOR")
-        .ok()
-        .and_then(|inner| inner.parse::<bool>().ok())
-        .unwrap_or_else(|| std::io::stdout().is_terminal())
-}
-
-fn retrieve_alias_pathbuf(alias: &str, real_dir: &str) -> Result<(String, PathBuf)> {
-    let pb = Path::new(real_dir)
-        .canonicalize()
-        .with_context(|| format!("Unable to get the absolute path for \"{real_dir}\""))?;
-
-    if let Ok(pb_metadata) = pb.metadata() {
-        if !pb_metadata.is_dir() {
-            bail!("\"{real_dir}\" exists, but it is not a directory");
-        }
-    } else {
-        bail!("Directory \"{real_dir}\" does not exist");
-    }
-
-    Ok((alias.to_string(), pb))
-}
-
-/// Parses a mapdir from a string
-pub fn parse_mapdir(entry: &str) -> Result<(String, PathBuf)> {
-    // We try first splitting by `::`
-    if let [alias, real_dir] = entry.split("::").collect::<Vec<&str>>()[..] {
-        retrieve_alias_pathbuf(alias, real_dir)
-    }
-    // And then we try splitting by `:` (for compatibility with previous API)
-    else if let [alias, real_dir] = entry.split(':').collect::<Vec<&str>>()[..] {
-        retrieve_alias_pathbuf(alias, real_dir)
-    } else {
-        bail!(
-            "Directory mappings must consist of two paths separate by a `::` or `:`. Found {}",
-            &entry
-        )
-    }
-}
-
-/// Parses an environment variable.
-pub fn parse_envvar(entry: &str) -> Result<(String, String)> {
-    let entry = entry.trim();
-
-    match entry.find('=') {
-        None => bail!(
-            "Environment variable must be of the form `<name>=<value>`; found `{}`",
-            &entry
-        ),
-
-        Some(0) => bail!(
-            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `{}`",
-            &entry
-        ),
-
-        Some(position) if position == entry.len() - 1 => bail!(
-            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `{}`",
-            &entry
-        ),
-
-        Some(position) => Ok((entry[..position].into(), entry[position + 1..].into())),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::parse_envvar;
-
-    #[test]
-    fn test_parse_envvar() {
-        assert_eq!(
-            parse_envvar("A").unwrap_err().to_string(),
-            "Environment variable must be of the form `<name>=<value>`; found `A`"
-        );
-        assert_eq!(
-            parse_envvar("=A").unwrap_err().to_string(),
-            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `=A`"
-        );
-        assert_eq!(
-            parse_envvar("A=").unwrap_err().to_string(),
-            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `A=`"
-        );
-        assert_eq!(parse_envvar("A=B").unwrap(), ("A".into(), "B".into()));
-        assert_eq!(parse_envvar("   A=B\t").unwrap(), ("A".into(), "B".into()));
-        assert_eq!(
-            parse_envvar("A=B=C=D").unwrap(),
-            ("A".into(), "B=C=D".into())
-        );
-    }
-}
diff --git a/lib/cli/Cargo.toml b/lib/cli/Cargo.toml
index fbac043c74..9ece867b88 100644
--- a/lib/cli/Cargo.toml
+++ b/lib/cli/Cargo.toml
@@ -32,26 +32,27 @@ 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"]
 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 +62,7 @@ compiler = [
 	"wasmer/compiler",
 	"wasmer-compiler/translator",
 	"wasmer-compiler/compiler",
+	"sys",
 ]
 wasmer-artifact-create = [
 	"compiler",
@@ -68,7 +70,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 +77,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 +88,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 = [
@@ -106,140 +107,137 @@ enable-serde = [
 	"wasmer-wasix/enable-serde",
 ]
 
+tokio-subscriber = ["dep:console-subscriber", "tokio/tracing"]
+
 [dependencies]
 # Repo-local dependencies.
 
-wasmer = { version = "=4.3.7", path = "../api", default-features = false }
-wasmer-compiler = { version = "=4.3.7", path = "../compiler", features = [
-	"compiler",
+wasmer = { version = "=7.0.0", path = "../api", default-features = false, features = ["headless"] }
+wasmer-compiler = { version = "=7.0.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 = "=7.0.0", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-singlepass = { version = "=7.0.0", path = "../compiler-singlepass", optional = true }
+wasmer-compiler-llvm = { version = "=7.0.0", path = "../compiler-llvm", optional = true }
+wasmer-package.workspace = true
+
+wasmer-vm = { version = "=7.0.0", path = "../vm", optional = true }
+wasmer-wasix = { path = "../wasix", version = "=0.700.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 = "=7.0.0", path = "../../tests/lib/wast", optional = true }
+wasmer-types = { version = "=7.0.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.700.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.700.0", path = "../virtual-net" }
+virtual-mio = { version = "0.700.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"
-
-# Used by the mount command
+webc.workspace = true
+wasmer-backend-api = { version = "=0.700.0", path = "../backend-api" }
+wasmer-sdk = { version = "=7.0.0", path = "../sdk" }
+wasmer-config = { version = "0.700.0", path = "../config" }
 
 shared-buffer = { workspace = true, optional = true }
 rkyv = { workspace = true, optional = true }
-fuse = { version = "0.3", optional = true }
-time01 = { package = "time", version = "0.1.45", optional = true }
-
 
 # Third-party dependencies.
 
 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"] }
-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"
-walkdir = "2.3.2"
-regex = "1.6.0"
+colored.workspace = true
+anyhow.workspace = true
+bytesize.workspace = true
+cfg-if.workspace = true
+tempfile.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+dirs.workspace = true
+path-clean.workspace = true
+target-lexicon = { workspace = true, features = ["std"] }
+indexmap.workspace = true
+walkdir.workspace = true
+regex.workspace = true
 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"
-cargo_metadata = "0.15.2"
-tar = "0.4.40"
-bytes = "1"
-thiserror = "1.0.37"
-log = "0.4.17"
-semver = "1.0.14"
-pathdiff = "0.2.1"
-sha2 = "0.10.6"
-object = "0.32.0"
-wasm-coredump-builder = { version = "0.1.11", optional = true }
-tracing = { version = "0.1" }
-tracing-subscriber = { version = "0.3", features = [
+parking_lot.workspace = true
+dialoguer.workspace = true
+hex.workspace = true
+flate2.workspace = true
+cargo_metadata.workspace = true
+tar.workspace = true
+bytes.workspace = true
+thiserror.workspace = true
+log.workspace = true
+semver.workspace = true
+pathdiff.workspace = true
+sha2.workspace = true
+object.workspace = true
+wasm-coredump-builder = { workspace = true, optional = true }
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = [
 	"env-filter",
 	"fmt",
 	"json",
+	"ansi"
 ] }
-async-trait = "0.1.68"
-tokio = { version = "1.28.1", features = ["macros", "rt-multi-thread"] }
-once_cell = "1.17.1"
-indicatif = "0.17.5"
-opener = "0.6.1"
-normpath = "=1.1.1"
+async-trait.workspace = true
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+once_cell.workspace = true
+indicatif.workspace = true
+opener.workspace = true
+normpath.workspace = true
 hyper = { workspace = true, features = ["server"] }
-hyper-util = { version = "0.1.5", features = ["tokio"] }
-http-body-util = "0.1.1"
-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"
-
+hyper-util = { workspace = true, features = ["tokio"] }
+http-body-util.workspace = true
+futures.workspace = true
+humantime.workspace = true
+interfaces = { workspace = true, optional = true }
+
+uuid = { workspace = true, features = ["v4"] }
+time = { workspace = true, features = ["macros"] }
+serde_yaml.workspace = true
+base64.workspace = true
+comfy-table.workspace = true
+git-version.workspace = true
+itertools.workspace = true
 
 # 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 }
+mac_address = { workspace = true, optional = true }
+#tun-tap = { workspace = true, features = ["tokio"], optional = true }
+
+clap_complete.workspace = true
+clap_mangen.workspace = true
+zip = { workspace = true, features = ["deflate"] }
+console.workspace = true
+dotenvy.workspace = true
+lzma-rs.workspace = true
 
-clap_complete = "4.5.2"
-clap_mangen = "0.2.20"
-zip = { version = "2.1.3", default-features = false, features = ["deflate"] }
-console = "0.15.8"
-dotenvy = "0.15.7"
+console-subscriber = { workspace = true, optional = true }
 
 # 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 = { workspace = true, default-features = true, features = ["derive", "env"] }
 [target.'cfg(target_family = "wasm")'.dependencies]
-clap = { version = "4.3.7", default-features = false, features = [
+clap = { workspace = true, default-features = false, features = [
 	"std",
 	"help",
 	"usage",
@@ -249,38 +247,41 @@ 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",
 	"multipart",
 	"gzip",
+	"zstd",
 ] }
 
-[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",
+	"zstd",
 ] }
 
+
 [build-dependencies]
-chrono = { version = "^0.4", default-features = false, features = [
+chrono = { workspace = true, default-features = false, features = [
 	"std",
 	"clock",
 ] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-unix_mode = "0.1.3"
+unix_mode.workspace = true
 
 
 [dev-dependencies]
-assert_cmd = "2.0.11"
-predicates = "3.0.3"
-pretty_assertions = "1.3.0"
+assert_cmd.workspace = true
+predicates.workspace = true
+pretty_assertions.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
-colored = "2.0.0"
+colored.workspace = true
 
 [package.metadata.binstall]
 pkg-fmt = "tgz"
@@ -315,3 +316,4 @@ bin-dir = "bin/{ bin }.exe"
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
+features = ["wasmer/cranelift"]
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..28df3c148f 100644
--- a/lib/cli/build.rs
+++ b/lib/cli/build.rs
@@ -1,27 +1,7 @@
-use std::process::Command;
-
 use chrono::prelude::*;
 
 pub fn main() {
-    // Set WASMER_GIT_HASH
-    let git_hash = Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .output()
-        .ok()
-        .and_then(|output| String::from_utf8(output.stdout).ok())
-        .unwrap_or_default();
-    println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH={}", git_hash);
-
-    if git_hash.len() > 5 {
-        println!(
-            "cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT={}",
-            &git_hash[..7]
-        );
-    } else {
-        println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT=???????");
-    }
-
     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..78a4312e11
--- /dev/null
+++ b/lib/cli/src/backend.rs
@@ -0,0 +1,780 @@
+//! 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::{Context, Result, bail};
+#[cfg(feature = "sys")]
+use wasmer::sys::*;
+use wasmer::*;
+use wasmer_types::{Features, target::Target};
+
+#[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(short, 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(short, 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(short, 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,
+
+    /// Debug directory, where IR and object files will be written to.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long, alias = "llvm-debug-dir")]
+    compiler_debug_dir: Option<PathBuf>,
+
+    /// Enable a profiler.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long, value_enum)]
+    profiler: Option<Profiler>,
+
+    /// 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.
+    #[cfg(feature = "llvm")]
+    #[clap(long)]
+    enable_pass_params_opt: bool,
+
+    /// Sets the number of threads used to compile the input module(s).
+    #[clap(long, alias = "llvm-num-threads")]
+    compiler_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().context("no compiler backend enabled")?;
+        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 enabled Wasm features.
+    pub fn get_features(&self, default_features: &Features) -> Result<Features> {
+        if self.features.all {
+            return Ok(Features::all());
+        }
+
+        let mut result = default_features.clone();
+        if !self.features.disable_threads {
+            result.threads(true);
+        }
+        if self.features.disable_threads {
+            result.threads(false);
+        }
+        if self.features.multi_value {
+            result.multi_value(true);
+        }
+        if self.features.simd {
+            result.simd(true);
+        }
+        if self.features.bulk_memory {
+            result.bulk_memory(true);
+        }
+        if self.features.reference_types {
+            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> {
+        if self.features.all {
+            return Ok(Features::all());
+        }
+
+        let mut features = Features::detect_from_wasm(wasm_bytes)?;
+
+        // Merge with user-configured features
+        if !self.features.disable_threads {
+            features.threads(true);
+        }
+        if self.features.reference_types {
+            features.reference_types(true);
+        }
+        if self.features.simd {
+            features.simd(true);
+        }
+        if self.features.bulk_memory {
+            features.bulk_memory(true);
+        }
+        if self.features.multi_value {
+            features.multi_value(true);
+        }
+        if self.features.tail_call {
+            features.tail_call(true);
+        }
+        if self.features.module_linking {
+            features.module_linking(true);
+        }
+        if self.features.multi_memory {
+            features.multi_memory(true);
+        }
+        if self.features.memory64 {
+            features.memory64(true);
+        }
+        if self.features.exceptions {
+            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(),
+                    }
+                }
+                if let Some(mut debug_dir) = self.compiler_debug_dir.clone() {
+                    use wasmer_compiler_singlepass::SinglepassCallbacks;
+
+                    debug_dir.push("singlepass");
+                    config.callbacks(Some(SinglepassCallbacks::new(debug_dir)?));
+                }
+                if let Some(num_threads) = self.compiler_threads {
+                    config.num_threads(num_threads);
+                }
+                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(),
+                    }
+                }
+                if let Some(mut debug_dir) = self.compiler_debug_dir.clone() {
+                    use wasmer_compiler_cranelift::CraneliftCallbacks;
+
+                    debug_dir.push("cranelift");
+                    config.callbacks(Some(CraneliftCallbacks::new(debug_dir)?));
+                }
+                if let Some(num_threads) = self.compiler_threads {
+                    config.num_threads(num_threads);
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "llvm")]
+            BackendType::LLVM => {
+                use wasmer_compiler_llvm::LLVMCallbacks;
+                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.compiler_threads {
+                    config.num_threads(num_threads);
+                }
+
+                if let Some(mut debug_dir) = self.compiler_debug_dir.clone() {
+                    debug_dir.push("llvm");
+                    config.callbacks(Some(LLVMCallbacks::new(debug_dir)?));
+                    config.verbose_asm(true);
+                }
+                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}` compiler is not included in this binary.")
+            }
+        };
+
+        #[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(),
+                    }
+                }
+                if let Some(mut debug_dir) = runtime_opts.compiler_debug_dir.clone() {
+                    use wasmer_compiler_singlepass::SinglepassCallbacks;
+
+                    debug_dir.push("singlepass");
+                    config.callbacks(Some(SinglepassCallbacks::new(debug_dir)?));
+                }
+                if let Some(num_threads) = runtime_opts.compiler_threads {
+                    config.num_threads(num_threads);
+                }
+                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(),
+                    }
+                }
+                if let Some(mut debug_dir) = runtime_opts.compiler_debug_dir.clone() {
+                    use wasmer_compiler_cranelift::CraneliftCallbacks;
+
+                    debug_dir.push("cranelift");
+                    config.callbacks(Some(CraneliftCallbacks::new(debug_dir)?));
+                }
+                if let Some(num_threads) = runtime_opts.compiler_threads {
+                    config.num_threads(num_threads);
+                }
+                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 wasmer_compiler_llvm::LLVMCallbacks;
+                use wasmer_types::entity::EntityRef;
+
+                let mut config = wasmer_compiler_llvm::LLVM::new();
+
+                if let Some(mut debug_dir) = runtime_opts.compiler_debug_dir.clone() {
+                    debug_dir.push("llvm");
+                    config.callbacks(Some(LLVMCallbacks::new(debug_dir)?));
+                    config.verbose_asm(true);
+                }
+                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.compiler_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..3f690822c4 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};
+use super::{CStatement, CType, generate_c};
 
 /// 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..d06d12c5ec 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::{
+    WasmerClient,
+    types::{Bindings, ProgrammingLanguage},
+};
+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())
@@ -54,19 +58,22 @@ impl Add {
             )
         })?;
 
-        anyhow::ensure!(status.success(), "Command failed: {:?}", cmd);
+        anyhow::ensure!(status.success(), "Command failed: {cmd:?}");
 
         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
             }
         }
     }
@@ -162,11 +173,7 @@ impl Target {
                 if Command::new("yarn").arg("--version").output().is_err() {
                     return Err(anyhow::anyhow!("yarn not installed"));
                 }
-                if dev {
-                    "yarn add --dev"
-                } else {
-                    "yarn add"
-                }
+                if dev { "yarn add --dev" } else { "yarn add" }
             }
             Target::Npm { dev } => {
                 if Command::new("npm").arg("--version").output().is_err() {
@@ -182,11 +189,7 @@ impl Target {
                 if Command::new("pnpm").arg("--version").output().is_err() {
                     return Err(anyhow::anyhow!("pnpm not installed"));
                 }
-                if dev {
-                    "pnpm add --dev"
-                } else {
-                    "pnpm add"
-                }
+                if dev { "pnpm add --dev" } else { "pnpm add" }
             }
         };
         let mut command_line = command_line.to_string();
diff --git a/lib/cli/src/commands/app/create.rs b/lib/cli/src/commands/app/create.rs
index b98ec43da0..e57b13b21a 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},
@@ -11,12 +10,14 @@ use std::{
 
 use anyhow::Context;
 use colored::Colorize;
-use dialoguer::{theme::ColorfulTheme, Confirm, Select};
+use dialoguer::{Confirm, Select, theme::ColorfulTheme};
 use futures::stream::TryStreamExt;
-use is_terminal::IsTerminal;
-use wasmer_api::{
-    types::{AppTemplate, TemplateLanguage},
+use indexmap::IndexMap;
+use path_clean::PathClean;
+use std::io::IsTerminal as _;
+use wasmer_backend_api::{
     WasmerClient,
+    types::{AppTemplate, TemplateLanguage},
 };
 use wasmer_config::{app::AppConfigV1, package::PackageSource};
 
@@ -28,7 +29,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 +53,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 +158,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 +173,8 @@ impl CmdAppCreate {
             scaling: None,
             locality: None,
             redirect: None,
-            extra: HashMap::new(),
+            extra: IndexMap::new(),
+            jobs: None,
         }
     }
 
@@ -173,7 +200,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 +217,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
         };
@@ -208,7 +235,9 @@ impl CmdAppCreate {
             if self.non_interactive {
                 if !self.quiet {
                     eprintln!("The current directory is not empty.");
-                    eprintln!("Use the `--dir` flag to specify another directory, or remove files from the currently selected one.")
+                    eprintln!(
+                        "Use the `--dir` flag to specify another directory, or remove files from the currently selected one."
+                    )
                 }
                 anyhow::bail!("Stopping as the directory is not empty")
             } else {
@@ -245,7 +274,10 @@ impl CmdAppCreate {
         let (manifest_path, _) = if let Some(res) = load_package_manifest(&app_dir)? {
             res
         } else if self.use_local_manifest {
-            anyhow::bail!("The --use_local_manifest flag was passed, but path {} does not contain a valid package manifest.", app_dir.display())
+            anyhow::bail!(
+                "The --use_local_manifest flag was passed, but path {} does not contain a valid package manifest.",
+                app_dir.display()
+            )
         } else {
             return Ok(false);
         };
@@ -264,7 +296,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 +318,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 +336,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 +393,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(),
         );
 
@@ -373,11 +407,11 @@ impl CmdAppCreate {
             None => return Ok(Vec::new()),
         };
 
-        if let (Some(a), Some(b)) = (cached_items.first(), first_page.first()) {
-            if a == b {
-                // Cached items are up to date, no need to query more.
-                return Ok(cached_items);
-            }
+        if let (Some(a), Some(b)) = (cached_items.first(), first_page.first())
+            && a == b
+        {
+            // Cached items are up to date, no need to query more.
+            return Ok(cached_items);
         }
 
         let mut items = first_page;
@@ -446,7 +480,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,
         ));
 
@@ -455,11 +489,11 @@ impl CmdAppCreate {
             None => return Ok(Vec::new()),
         };
 
-        if let (Some(a), Some(b)) = (cached_items.first(), first_page.first()) {
-            if a == b {
-                // Cached items are up to date, no need to query more.
-                return Ok(cached_items);
-            }
+        if let (Some(a), Some(b)) = (cached_items.first(), first_page.first())
+            && a == b
+        {
+            // Cached items are up to date, no need to query more.
+            return Ok(cached_items);
         }
 
         let mut items = first_page;
@@ -484,16 +518,22 @@ impl CmdAppCreate {
     }
 
     // A utility function used to fetch the URL of the template to use.
-    async fn get_template_url(&self, client: &WasmerClient) -> anyhow::Result<url::Url> {
-        let mut url = if let Some(template) = &self.template {
+    async fn get_template_url(
+        &self,
+        client: &WasmerClient,
+    ) -> anyhow::Result<(url::Url, Option<PathBuf>)> {
+        let (mut url, selected_template): (url::Url, Option<AppTemplate>) = if let Some(template) =
+            &self.template
+        {
             if let Ok(url) = url::Url::parse(template) {
-                url
+                (url, None)
             } 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)?
+                (url::Url::parse(&template.repo_url)?, Some(template))
             } else {
-                anyhow::bail!("Template '{}' not found in the registry", template)
+                anyhow::bail!("Template '{template}' not found in the registry")
             }
         } else {
             if self.non_interactive {
@@ -570,18 +610,36 @@ impl CmdAppCreate {
                 )
             }
 
-            url::Url::parse(&selected_template.repo_url)?
+            (
+                url::Url::parse(&selected_template.repo_url)?,
+                Some(selected_template.clone()),
+            )
         };
 
         let url = if url.path().contains("archive/refs/heads") || url.path().contains("/zipball/") {
             url
         } else {
             let old_path = url.path();
-            url.set_path(&format!("{old_path}/zipball/main"));
+            let branch = if let Some(ref template) = selected_template {
+                template.branch.clone().unwrap_or("main".to_string())
+            } else {
+                "main".to_string()
+            };
+            url.set_path(&format!("{old_path}/zipball/{branch}"));
             url
         };
 
-        Ok(url)
+        if let Some(ref template) = selected_template
+            && let Some(root_dir) = &template.root_dir
+        {
+            let mut path_root_dir = PathBuf::from(root_dir);
+            if path_root_dir.is_absolute() {
+                path_root_dir = path_root_dir.strip_prefix("/")?.to_path_buf();
+            }
+            return Ok((url, Some(path_root_dir)));
+        }
+
+        Ok((url, None))
     }
 
     async fn create_from_template(
@@ -592,12 +650,17 @@ impl CmdAppCreate {
     ) -> anyhow::Result<bool> {
         let client = match client {
             Some(client) => client,
-            None => anyhow::bail!("Cannot"),
+            None => anyhow::bail!("Cannot create app from template in offline mode"),
         };
 
-        let url = self.get_template_url(client).await?;
-
-        tracing::info!("Downloading template from url {url}");
+        let (url, mut root_dir) = self.get_template_url(client).await?;
+        root_dir = root_dir.map(|v| v.clean());
+        let root_dir_str = if let Some(ref root_dir) = root_dir {
+            root_dir.display().to_string()
+        } else {
+            "./".to_string()
+        };
+        tracing::info!("Downloading template from url {url}, using root dir {root_dir_str}");
 
         let output_path = self.get_output_dir(app_name).await?;
         let pb = indicatif::ProgressBar::new_spinner();
@@ -609,16 +672,17 @@ impl CmdAppCreate {
                 .tick_strings(&["✶", "✸", "✹", "✺", "✹", "✷"]),
         );
 
-        pb.set_message("Downloading package..");
+        pb.set_message("Downloading template...");
 
         let response = reqwest::get(url).await?;
         let bytes = response.bytes().await?;
-        pb.set_message("Unpacking the template..");
+        pb.set_message("Unpacking the template...");
 
         let cursor = Cursor::new(bytes);
         let mut archive = zip::ZipArchive::new(cursor)?;
 
         // Extract the files to the output path
+        // If root dir is specified, extract only the files inside of the root dir
         for entry in 0..archive.len() {
             let mut entry = archive
                 .by_index(entry)
@@ -626,22 +690,30 @@ impl CmdAppCreate {
 
             let path = entry.mangled_name();
 
-            let path: PathBuf = {
+            // We skip the top-level directory, as Github archives always contain a top-level directory
+            // named after the repository name and latest commit hash.
+            let mut path: PathBuf = {
                 let mut components = path.components();
                 components.next();
                 components.collect()
             };
 
-            if path.to_str().unwrap_or_default().contains(".github") {
-                continue;
+            tracing::info!("Extracting file {path:?}");
+
+            if let Some(ref root_dir) = root_dir {
+                if !path.clean().starts_with(root_dir) {
+                    continue;
+                } else {
+                    path = path.strip_prefix(root_dir)?.to_path_buf();
+                }
             }
 
             let path = output_path.join(path);
 
-            if let Some(parent) = path.parent() {
-                if !parent.exists() {
-                    std::fs::create_dir_all(parent)?;
-                }
+            if let Some(parent) = path.parent()
+                && !parent.exists()
+            {
+                std::fs::create_dir_all(parent)?;
             }
 
             if !path.exists() {
@@ -685,6 +757,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 +785,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 +797,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 +822,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 +831,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 +882,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..4bcf49dd30 100644
--- a/lib/cli/src/commands/app/delete.rs
+++ b/lib/cli/src/commands/app/delete.rs
@@ -1,7 +1,7 @@
 //! Delete an Edge app.
 
 use dialoguer::Confirm;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 
 use super::util::AppIdentOpts;
 use crate::{commands::AsyncCliCommand, config::WasmerEnv};
@@ -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..c43f510898 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 super::{AsyncCliCommand, util::login_user};
 use crate::{
-    commands::{app::create::CmdAppCreate, package::publish::PackagePublish, PublishWait},
+    commands::{
+        PublishWait,
+        app::create::{CmdAppCreate, minimal_app_config, write_app_config},
+        package::publish::PackagePublish,
+    },
     config::WasmerEnv,
     opts::ItemFormatOpts,
-    utils::load_package_manifest,
+    utils::{DEFAULT_PACKAGE_MANIFEST_FILE, load_package_manifest},
 };
 use anyhow::Context;
+use bytesize::ByteSize;
 use colored::Colorize;
-use dialoguer::Confirm;
-use is_terminal::IsTerminal;
+use dialoguer::{Confirm, theme::ColorfulTheme};
+use indexmap::IndexMap;
+use std::io::IsTerminal as _;
 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::{
     WasmerClient,
+    types::{AutoBuildDeployAppLogKind, DeployApp, DeployAppVersion},
 };
 use wasmer_config::{
     app::AppConfigV1,
     package::{PackageIdent, PackageSource},
 };
+use wasmer_sdk::app::deploy_remote_build::{
+    DeployRemoteEvent, DeployRemoteOpts, deploy_app_remote,
+};
 
-// 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(());
+        }
 
-                (f, base_dir_path.clone())
+        let (app_config_path, base_dir_path) = self.resolve_app_paths()?;
+
+        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()
@@ -264,7 +603,10 @@ impl AsyncCliCommand for CmdAppDeploy {
                 // Create already points back to deploy.
                 return self.create().await;
             } else {
-                anyhow::bail!("No app configuration was found in {}. Create an app before deploying or re-run in interactive mode!", app_config_path.display());
+                anyhow::bail!(
+                    "No app configuration was found in {}. Create an app before deploying or re-run in interactive mode!",
+                    app_config_path.display()
+                );
             }
         }
 
@@ -276,7 +618,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 +629,16 @@ 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()));
+                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,8 +727,45 @@ 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) => {
+            PackageSource::Path(path) => {
                 let path = PathBuf::from(path);
 
                 let path = if path.is_absolute() {
@@ -424,14 +807,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 +861,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,
@@ -521,7 +909,7 @@ impl AsyncCliCommand for CmdAppDeploy {
                         }
                     }
                 } else {
-                    log::info!("Using package {}", app_config.package.to_string());
+                    log::info!("Using package {}", app_config.package);
                     DeployAppOpts {
                         app: &app_config,
                         original_config: Some(app_config.clone().to_yaml_value().unwrap()),
@@ -533,7 +921,7 @@ impl AsyncCliCommand for CmdAppDeploy {
                 }
             }
             _ => {
-                log::info!("Using package {}", app_config.package.to_string());
+                log::info!("Using package {}", app_config.package);
                 DeployAppOpts {
                     app: &app_config,
                     original_config: Some(app_config.clone().to_yaml_value().unwrap()),
@@ -549,13 +937,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 +986,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 +1001,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 +1101,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 +1142,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 +1239,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..9a487d5497 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 time::{OffsetDateTime, format_description::well_known::Rfc3339};
+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..f0782fe164 100644
--- a/lib/cli/src/commands/app/regions/list.rs
+++ b/lib/cli/src/commands/app/regions/list.rs
@@ -1,5 +1,5 @@
 use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ListFormatOpts};
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 
 /// List available Edge regions.
 #[derive(clap::Parser, Debug)]
@@ -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..0719184f3c 100644
--- a/lib/cli/src/commands/app/secrets/create.rs
+++ b/lib/cli/src/commands/app/secrets/create.rs
@@ -1,17 +1,17 @@
 use super::utils::Secret;
 use crate::{
-    commands::{app::util::AppIdentFlag, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentFlag},
     config::WasmerEnv,
 };
 use anyhow::Context;
 use colored::Colorize;
 use dialoguer::theme::ColorfulTheme;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 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,14 +95,17 @@ 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();
 
         for secret in secrets {
             if sset.contains(&secret.name) {
                 if self.non_interactive {
-                    anyhow::bail!("Cannot create secret '{}' as it already exists. Use the `update` command instead.", secret.name.bold());
+                    anyhow::bail!(
+                        "Cannot create secret '{}' as it already exists. Use the `update` command instead.",
+                        secret.name.bold()
+                    );
                 } else {
                     if ret.contains_key(&secret.name) {
                         eprintln!(
@@ -121,7 +124,10 @@ impl CmdAppSecretsCreate {
                         .interact()?;
 
                     if !res {
-                        eprintln!("Cannot create secret '{}' as it already exists. Use the `update` command instead.", secret.name.bold());
+                        eprintln!(
+                            "Cannot create secret '{}' as it already exists. Use the `update` command instead.",
+                            secret.name.bold()
+                        );
                     }
                 }
             }
@@ -142,7 +148,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 +179,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..62333115a5 100644
--- a/lib/cli/src/commands/app/secrets/delete.rs
+++ b/lib/cli/src/commands/app/secrets/delete.rs
@@ -1,12 +1,12 @@
 use crate::{
-    commands::{app::util::AppIdentFlag, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentFlag},
     config::WasmerEnv,
 };
 use colored::Colorize;
 use dialoguer::theme::ColorfulTheme;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 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 => {
@@ -149,7 +150,9 @@ impl AsyncCliCommand for CmdAppSecretsDelete {
             self.delete_from_file(&client, file, app_id).await
         } else if self.all {
             if self.non_interactive && !self.force {
-                anyhow::bail!("Refusing to delete all secrets in non-interactive mode without the `--force` flag.")
+                anyhow::bail!(
+                    "Refusing to delete all secrets in non-interactive mode without the `--force` flag."
+                )
             }
             let secrets = get_secrets(&client, &app_id).await?;
             for secret in secrets {
diff --git a/lib/cli/src/commands/app/secrets/list.rs b/lib/cli/src/commands/app/secrets/list.rs
index 6edb25c3cd..b1a92375e7 100644
--- a/lib/cli/src/commands/app/secrets/list.rs
+++ b/lib/cli/src/commands/app/secrets/list.rs
@@ -1,10 +1,10 @@
-use super::utils::{get_secrets, BackendSecretWrapper};
+use super::utils::{BackendSecretWrapper, get_secrets};
 use crate::{
-    commands::{app::util::AppIdentFlag, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentFlag},
     config::WasmerEnv,
     opts::ListFormatOpts,
 };
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 use std::path::PathBuf;
 
 /// Retrieve the value of an existing app secret.
diff --git a/lib/cli/src/commands/app/secrets/reveal.rs b/lib/cli/src/commands/app/secrets/reveal.rs
index ae16d67bfa..781216dd1c 100644
--- a/lib/cli/src/commands/app/secrets/reveal.rs
+++ b/lib/cli/src/commands/app/secrets/reveal.rs
@@ -1,12 +1,12 @@
 use super::utils;
 use crate::{
-    commands::{app::util::AppIdentFlag, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentFlag},
     config::WasmerEnv,
     opts::ListFormatOpts,
     utils::render::{ItemFormat, ListFormat},
 };
 use dialoguer::theme::ColorfulTheme;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 use std::path::PathBuf;
 
 /// Reveal the value of an existing app secret.
diff --git a/lib/cli/src/commands/app/secrets/update.rs b/lib/cli/src/commands/app/secrets/update.rs
index 32c20bd586..7ead78ae2b 100644
--- a/lib/cli/src/commands/app/secrets/update.rs
+++ b/lib/cli/src/commands/app/secrets/update.rs
@@ -1,17 +1,17 @@
 use super::utils::Secret;
 use crate::{
-    commands::{app::util::AppIdentFlag, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentFlag},
     config::WasmerEnv,
 };
 use anyhow::Context;
 use colored::Colorize;
 use dialoguer::theme::ColorfulTheme;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 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![];
@@ -108,7 +108,10 @@ impl CmdAppSecretsUpdate {
         for secret in secrets {
             if !sset.contains(secret.name.as_str()) {
                 if self.non_interactive {
-                    anyhow::bail!("Cannot update secret '{}' in app {app_id} as it does not exist yet. Use the `create` command instead.", secret.name.bold());
+                    anyhow::bail!(
+                        "Cannot update secret '{}' in app {app_id} as it does not exist yet. Use the `create` command instead.",
+                        secret.name.bold()
+                    );
                 } else {
                     eprintln!(
                         "Secret '{}' does not exist for the selected app.",
@@ -120,7 +123,10 @@ impl CmdAppSecretsUpdate {
                         .interact()?;
 
                     if !res {
-                        eprintln!("Cannot update secret '{}' as it does not exist yet. Use the `create` command instead.", secret.name.bold());
+                        eprintln!(
+                            "Cannot update secret '{}' as it does not exist yet. Use the `create` command instead.",
+                            secret.name.bold()
+                        );
                     }
                 }
             }
@@ -136,7 +142,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 +173,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..b5c3d7c45c 100644
--- a/lib/cli/src/commands/app/secrets/utils/mod.rs
+++ b/lib/cli/src/commands/app/secrets/utils/mod.rs
@@ -1,14 +1,14 @@
 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::{WasmerClient, types::Secret as BackendSecret};
 
-use crate::commands::app::util::{get_app_config_from_dir, prompt_app_ident, AppIdent};
+use crate::commands::app::util::{AppIdent, get_app_config_from_dir, prompt_app_ident};
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub(super) struct Secret {
@@ -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 {
@@ -124,10 +130,12 @@ pub(super) async fn get_app_id(
                 Some(app.id.into_inner())
             } else {
                 if !quiet {
-                    eprintln!("{}: the app found in {} does not exist.\n{}: maybe it was not deployed yet?", 
-                            "Warning".bold().yellow(), 
-                            format!("'{}'", path.display()).dimmed(), 
-                            "Hint".bold());
+                    eprintln!(
+                        "{}: the app found in {} does not exist.\n{}: maybe it was not deployed yet?",
+                        "Warning".bold().yellow(),
+                        format!("'{}'", path.display()).dimmed(),
+                        "Hint".bold()
+                    );
                 }
                 None
             }
@@ -140,10 +148,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..f34bd1afcd 100644
--- a/lib/cli/src/commands/app/util.rs
+++ b/lib/cli/src/commands/app/util.rs
@@ -1,12 +1,12 @@
 use std::{path::Path, str::FromStr};
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use colored::Colorize;
-use dialoguer::{theme::ColorfulTheme, Confirm};
-use wasmer_api::{
+use dialoguer::{Confirm, theme::ColorfulTheme};
+use wasmer_backend_api::{
+    WasmerClient,
     global_id::{GlobalId, NodeKind},
     types::DeployApp,
-    WasmerClient,
 };
 use wasmer_config::app::AppConfigV1;
 
@@ -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)]
@@ -253,7 +340,9 @@ pub(super) async fn login_user(
                 Some(n) => n,
                 None => String::from("wasmer"),
             };
-            eprintln!("You are not logged in. Use the `--token` flag or log in (use `{bin_name} login`) to {msg}.");
+            eprintln!(
+                "You are not logged in. Use the `--token` flag or log in (use `{bin_name} login`) to {msg}."
+            );
 
             anyhow::bail!("Stopping execution as the user is not logged in.")
         }
@@ -262,16 +351,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 +367,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..3ca7172fc9 100644
--- a/lib/cli/src/commands/app/version/get.rs
+++ b/lib/cli/src/commands/app/version/get.rs
@@ -1,9 +1,10 @@
 use anyhow::Context;
 
 use crate::{
-    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentOpts},
     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..eb6a5399d5 100644
--- a/lib/cli/src/commands/app/version/list.rs
+++ b/lib/cli/src/commands/app/version/list.rs
@@ -1,7 +1,7 @@
-use wasmer_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
+use wasmer_backend_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
 
 use crate::{
-    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentOpts},
     config::WasmerEnv,
     opts::ListFormatOpts,
 };
@@ -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..e84cd6f63d 100644
--- a/lib/cli/src/commands/app/volumes/credentials/mod.rs
+++ b/lib/cli/src/commands/app/volumes/credentials/mod.rs
@@ -1,7 +1,7 @@
 pub(super) mod rotate_secrets;
 
 use crate::{
-    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentOpts},
     config::WasmerEnv,
 };
 
@@ -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..28507dcb70 100644
--- a/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs
+++ b/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs
@@ -1,8 +1,8 @@
 use super::ItemFormatOpts;
 use crate::{
     commands::{
-        app::util::{AppIdent, AppIdentOpts},
         AsyncCliCommand,
+        app::util::{AppIdent, AppIdentOpts},
     },
     config::WasmerEnv,
 };
@@ -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..45b7f8d44e 100644
--- a/lib/cli/src/commands/auth/login/auth_server.rs
+++ b/lib/cli/src/commands/auth/login/auth_server.rs
@@ -1,6 +1,6 @@
 use super::AuthorizationState;
 use http_body_util::BodyExt;
-use hyper::{body::Incoming, Request, Response, StatusCode};
+use hyper::{Request, Response, StatusCode, body::Incoming};
 use reqwest::{Body, Method};
 use tokio::net::TcpListener;
 
@@ -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..3a6ca6ea1c 100644
--- a/lib/cli/src/commands/auth/login/mod.rs
+++ b/lib/cli/src/commands/auth/login/mod.rs
@@ -8,9 +8,9 @@ use crate::{
     commands::AsyncCliCommand,
     config::{UpdateRegistry, UserRegistry, WasmerConfig, WasmerEnv},
 };
-use futures_util::{stream::FuturesUnordered, StreamExt};
+use futures_util::{StreamExt, stream::FuturesUnordered};
 use std::{path::PathBuf, time::Duration};
-use wasmer_api::{types::Nonce, WasmerClient};
+use wasmer_backend_api::{WasmerClient, types::Nonce};
 
 #[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!"))
@@ -261,7 +256,11 @@ impl AsyncCliCommand for Login {
                 match self.login_and_save(&env, token).await {
                     Ok(s) => {
                         print!("Done!");
-                        println!("\n{} Login for Wasmer user {:?} saved","✔".green().bold(), s)
+                        println!(
+                            "\n{} Login for Wasmer user {:?} saved",
+                            "✔".green().bold(),
+                            s
+                        )
                     }
                     Err(_) => print!(
                         "Warning: no user found on {:?} with the provided token.\nToken saved regardless.",
@@ -357,7 +356,8 @@ mod tests {
             .get_opts()
             .filter(|arg| arg.get_id() != "token")
             .collect();
-        let login_opts: Vec<_> = login.get_opts().collect();
+        // the login opts, skipping the first positional argument (no-browser)
+        let login_opts: Vec<_> = login.get_opts().skip(1).collect();
 
         assert_eq!(wasmer_env_opts, login_opts);
 
@@ -384,12 +384,13 @@ mod tests {
     /// See https://github.com/wasmerio/wasmer/issues/4147.
     #[test]
     fn login_with_invalid_token_does_not_panic() {
+        let temp = TempDir::new().unwrap();
         let cmd = Login {
             no_browser: true,
-            wasmer_dir: crate::config::DEFAULT_WASMER_DIR.clone(),
+            wasmer_dir: temp.path().to_path_buf(),
             registry: Some("http://localhost:11".to_string().into()),
             token: Some("invalid".to_string()),
-            cache_dir: crate::config::DEFAULT_WASMER_CACHE_DIR.clone(),
+            cache_dir: temp.path().join("cache").to_path_buf(),
         };
 
         let res = cmd.run();
diff --git a/lib/cli/src/commands/auth/logout.rs b/lib/cli/src/commands/auth/logout.rs
index 5e6b9f76d7..b8934a6483 100644
--- a/lib/cli/src/commands/auth/logout.rs
+++ b/lib/cli/src/commands/auth/logout.rs
@@ -1,11 +1,11 @@
 use crate::{
     commands::AsyncCliCommand,
-    config::{WasmerConfig, WasmerEnv, DEFAULT_PROD_REGISTRY},
+    config::{DEFAULT_PROD_REGISTRY, WasmerConfig, WasmerEnv},
 };
 use colored::Colorize;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 
-/// 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/binfmt.rs b/lib/cli/src/commands/binfmt.rs
index 7af57e0675..a351368c00 100644
--- a/lib/cli/src/commands/binfmt.rs
+++ b/lib/cli/src/commands/binfmt.rs
@@ -5,9 +5,9 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use anyhow::{bail, Context, Result};
-use clap::Parser;
 use Action::*;
+use anyhow::{Context, Result, bail};
+use clap::Parser;
 
 #[derive(Debug, Parser, Clone, Copy)]
 enum Action {
@@ -91,15 +91,22 @@ impl Binfmt {
                         b":PFC",
                     ]
                     .concat(),
+                    [
+                        b":wasm32-webc:M::\\x00webc::".as_ref(),
+                        bin_path.as_os_str().as_bytes(),
+                        b":PFC",
+                    ]
+                    .concat(),
                 ])
             }
             _ => None,
         };
         let wasm_registration = self.binfmt_misc.join("wasm32");
         let wat_registration = self.binfmt_misc.join("wasm32-wat");
+        let webc_registration = self.binfmt_misc.join("wasm32-webc");
         match self.action {
-            Reregister | Unregister => {
-                let unregister = [wasm_registration, wat_registration]
+            Register | Reregister | Unregister => {
+                let unregister = [wasm_registration, wat_registration, webc_registration]
                     .iter()
                     .map(|registration| {
                         if registration.exists() {
@@ -112,10 +119,6 @@ impl Binfmt {
                                 .context("Couldn't write binfmt unregister request")?;
                             Ok(true)
                         } else {
-                            eprintln!(
-                                "Warning: {} does not exist, not unregistered.",
-                                registration.to_string_lossy()
-                            );
                             Ok(false)
                         }
                     })
@@ -126,13 +129,8 @@ impl Binfmt {
                     bail!("Nothing unregistered");
                 }
             }
-            _ => (),
         };
         if let Some(specs) = specs {
-            if cfg!(target_env = "gnu") {
-                // Approximate. ELF parsing for a proper check feels like overkill here.
-                eprintln!("Warning: wasmer has been compiled for glibc, and is thus likely dynamically linked. Invoking wasm binaries in chroots or mount namespaces (lxc, docker, ...) may not work.");
-            }
             specs
                 .iter()
                 .map(|spec| {
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..2e2cd0e22b 100644
--- a/lib/cli/src/commands/compile.rs
+++ b/lib/cli/src/commands/compile.rs
@@ -1,10 +1,10 @@
 use std::path::PathBuf;
 
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
-use wasmer::*;
+use wasmer::{sys::*, *};
 
-use crate::{common::HashAlgorithm, store::StoreOptions, warning};
+use crate::{backend::RuntimeOptions, warning};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer compile` subcommand
@@ -22,14 +22,10 @@ pub struct Compile {
     target_triple: Option<Triple>,
 
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
 
     #[clap(short = 'm')]
     cpu_features: Vec<CpuFeature>,
-
-    /// Hashing algorithm to be used for module hash
-    #[clap(long, value_enum)]
-    hash_algorithm: Option<HashAlgorithm>,
 }
 
 impl Compile {
@@ -57,11 +53,13 @@ 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 hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
-        engine.set_hash_algorithm(Some(hash_algorithm));
+        let module_contents = std::fs::read(&self.path)?;
+        if !is_wasm(&module_contents) {
+            bail!("`wasmer compile` only compiles WebAssembly files");
+        }
+
+        let engine = self.rt.get_engine_for_module(&module_contents, &target)?;
 
         let output_filename = self
             .output
@@ -73,17 +71,25 @@ impl Compile {
         match self.output.extension() {
             Some(ext) => {
                 if ext != recommended_extension {
-                    warning!("the output file has a wrong extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+                    warning!(
+                        "the output file has a wrong extension. We recommend using `{}.{}` for the chosen target",
+                        &output_filename,
+                        &recommended_extension
+                    )
                 }
             }
             None => {
-                warning!("the output file has no extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+                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..643f8fd2ca 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::{
+    VERSION,
+    config::{UpdateRegistry, WasmerConfig, WasmerEnv},
+};
 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,11 +270,11 @@ 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)
+                        if let Ok(client) = env.client()
+                            && let Some(u) =
+                                wasmer_backend_api::query::current_user(&client).await?
                         {
                             println!(
                                 "Successfully logged into registry {current_registry:?} as user {u:?}"
@@ -277,7 +285,7 @@ impl GetOrSet {
                         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..7eb04a7120 100644
--- a/lib/cli/src/commands/create_exe.rs
+++ b/lib/cli/src/commands/create_exe.rs
@@ -1,30 +1,31 @@
 //! 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, config::WasmerEnv};
+use anyhow::{Context, Result, anyhow, bail};
+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 +34,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,
@@ -41,8 +45,8 @@ pub struct CreateExe {
     #[clap(name = "OUTPUT PATH", short = 'o')]
     output: PathBuf,
 
-    /// Optional directorey used for debugging: if present, will output the zig command
-    /// for reproducing issues in a debug directory
+    /// Optional directory used for debugging: if present, will output the zig command
+    /// for reproducing issues in a debug directory.
     #[clap(long, name = "DEBUG PATH")]
     debug_dir: Option<PathBuf>,
 
@@ -93,11 +97,7 @@ pub struct CreateExe {
     cross_compile: CrossCompile,
 
     #[clap(flatten)]
-    compiler: CompilerOptions,
-
-    /// Hashing algorithm to be used for module hash
-    #[clap(long, value_enum)]
-    hash_algorithm: Option<HashAlgorithm>,
+    compiler: RuntimeOptions,
 }
 
 /// Url or version to download the release from
@@ -192,9 +192,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 +216,22 @@ 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 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 +249,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 +274,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 +362,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 +376,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 +527,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 +559,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
@@ -613,7 +624,8 @@ impl PrefixMapCompilation {
         if prefixes.len() != atoms.len() {
             println!(
                 "WARNING: invalid mapping of prefix and atoms: expected prefixes for {} atoms, got {} prefixes",
-                atoms.len(), prefixes.len()
+                atoms.len(),
+                prefixes.len()
             );
         }
 
@@ -670,7 +682,9 @@ impl PrefixMapCompilation {
                     manual_prefixes.insert(normalize_atom_name(&atoms[0].0), prefix.to_string());
                 }
                 _ => {
-                    return Err(anyhow::anyhow!("invalid --precompiled-atom {p:?} - correct format is ATOM:PREFIX:PATH or ATOM:PATH"));
+                    return Err(anyhow::anyhow!(
+                        "invalid --precompiled-atom {p:?} - correct format is ATOM:PREFIX:PATH or ATOM:PATH"
+                    ));
                 }
             }
         }
@@ -793,7 +807,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 +832,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 +858,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 +879,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 +888,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 +951,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 +1025,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 +1034,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 +1057,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 +1073,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 +1123,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 +1142,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 +1215,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,
@@ -1262,7 +1296,11 @@ fn link_exe_from_dir(
     include_path.push("include");
     if !include_path.exists() {
         // Can happen when we got the wrong library_path
-        return Err(anyhow::anyhow!("Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?", include_path.display(), library_path.display()));
+        return Err(anyhow::anyhow!(
+            "Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?",
+            include_path.display(),
+            library_path.display()
+        ));
     }
     cmd.arg("-I");
     cmd.arg(normalize_path(&format!("{}", include_path.display())));
@@ -1284,14 +1322,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
@@ -1345,10 +1384,9 @@ fn link_exe_from_dir(
         .context(anyhow!("Could not execute `zig`: {cmd:?}"))?;
 
     if !compilation.status.success() {
-        return Err(anyhow::anyhow!(String::from_utf8_lossy(
-            &compilation.stderr
-        )
-        .to_string()));
+        return Err(anyhow::anyhow!(
+            String::from_utf8_lossy(&compilation.stderr).to_string()
+        ));
     }
 
     // remove file if it exists - if not done, can lead to errors on copy
@@ -1394,7 +1432,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 {
@@ -1407,7 +1445,11 @@ fn link_objects_system_linker(
     include_path.push("include");
     if !include_path.exists() {
         // Can happen when we got the wrong library_path
-        return Err(anyhow::anyhow!("Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?", include_path.display(), libwasmer_path.display()));
+        return Err(anyhow::anyhow!(
+            "Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?",
+            include_path.display(),
+            libwasmer_path.display()
+        ));
     }
     command = command.arg("-I");
     command = command.arg(normalize_path(&format!("{}", include_path.display())));
@@ -1420,11 +1462,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()?;
 
@@ -1465,9 +1507,9 @@ fn generate_wasmer_main_c(
         let prefix = prefixes
             .get_prefix_for_atom(&utils::normalize_atom_name(a))
             .ok_or_else(|| {
+                let formatted_prefixes = format!("{prefixes:#?}");
                 anyhow::anyhow!(
-                    "cannot find prefix for atom {a} when generating wasmer_main.c ({:#?})",
-                    prefixes
+                    "cannot find prefix for atom {a} when generating wasmer_main.c ({formatted_prefixes})"
                 )
             })?;
         let atom_name = prefix.clone();
@@ -1521,10 +1563,10 @@ fn generate_wasmer_main_c(
         let prefix = prefixes
             .get_prefix_for_atom(&utils::normalize_atom_name(atom_names[0]))
             .ok_or_else(|| {
+                let formatted_prefixes = format!("{prefixes:#?}");
                 anyhow::anyhow!(
-                    "cannot find prefix for atom {} when generating wasmer_main.c ({:#?})",
-                    &atom_names[0],
-                    prefixes
+                    "cannot find prefix for atom {} when generating wasmer_main.c ({formatted_prefixes})",
+                    &atom_names[0]
                 )
             })?;
         write!(c_code_to_instantiate, "module = atom_{prefix};")?;
@@ -1533,15 +1575,14 @@ fn generate_wasmer_main_c(
             let prefix = prefixes
                 .get_prefix_for_atom(&utils::normalize_atom_name(a))
                 .ok_or_else(|| {
+                    let formatted_prefixes = format!("{prefixes:#?}");
                     anyhow::anyhow!(
-                        "cannot find prefix for atom {a} when generating wasmer_main.c ({:#?})",
-                        prefixes
+                        "cannot find prefix for atom {a} when generating wasmer_main.c ({formatted_prefixes})"
                     )
                 })?;
             writeln!(
                 c_code_to_instantiate,
-                "if (strcmp(selected_atom, \"{a}\") == 0) {{ module = atom_{}; }}",
-                prefix
+                "if (strcmp(selected_atom, \"{a}\") == 0) {{ module = atom_{prefix}; }}",
             )?;
         }
     }
@@ -1575,9 +1616,11 @@ pub(super) mod utils {
         path::{Path, PathBuf},
     };
 
-    use anyhow::{anyhow, Context};
+    use anyhow::{Context, anyhow};
     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 +1638,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,
@@ -1602,20 +1646,20 @@ pub(super) mod utils {
     ) -> Result<CrossCompileSetup, anyhow::Error> {
         let target = target_triple;
 
-        if let Some(tarball_path) = cross_subc.tarball.as_mut() {
-            if tarball_path.is_relative() {
-                *tarball_path = starting_cd.join(&tarball_path);
-                if !tarball_path.exists() {
-                    return Err(anyhow!(
-                        "Tarball path `{}` does not exist.",
-                        tarball_path.display()
-                    ));
-                } else if tarball_path.is_dir() {
-                    return Err(anyhow!(
-                        "Tarball path `{}` is a directory.",
-                        tarball_path.display()
-                    ));
-                }
+        if let Some(tarball_path) = cross_subc.tarball.as_mut()
+            && tarball_path.is_relative()
+        {
+            *tarball_path = starting_cd.join(&tarball_path);
+            if !tarball_path.exists() {
+                return Err(anyhow!(
+                    "Tarball path `{}` does not exist.",
+                    tarball_path.display()
+                ));
+            } else if tarball_path.is_dir() {
+                return Err(anyhow!(
+                    "Tarball path `{}` is a directory.",
+                    tarball_path.display()
+                ));
             }
         }
 
@@ -1640,13 +1684,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 +1706,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 +1719,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,54 +1740,64 @@ 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"))
-            {
-                return None;
-            }
+        if let Architecture::Aarch64(_) = target.architecture
+            && !(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") {
-                return None;
-            }
+        if let OperatingSystem::Windows = target.operating_system
+            && !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"))
-            {
-                return None;
-            }
+        if let OperatingSystem::Darwin(_) = target.operating_system
+            && !(filename.contains("apple") || filename.contains("darwin"))
+        {
+            return None;
         }
 
-        if let OperatingSystem::Linux = target.operating_system {
-            if !p.file_name()?.to_str()?.contains("linux") {
-                return None;
-            }
+        if let OperatingSystem::Linux = target.operating_system
+            && !filename.contains("linux")
+        {
+            return None;
         }
 
         Some(true)
@@ -1799,7 +1850,9 @@ pub(super) mod utils {
         })
         .cloned()
         .ok_or_else(|| {
-            anyhow!("Could not find libwasmer.a for {} target in the provided tarball path (files = {files:#?})", target)
+            anyhow!(
+                "Could not find libwasmer.a for {target} target in the provided tarball path (files = {files:#?})"
+            )
         })
     }
 
@@ -1819,33 +1872,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 +1912,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 +1929,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)
@@ -1900,14 +1949,18 @@ pub(super) mod utils {
 
     pub(super) fn find_zig_binary(path: Option<PathBuf>) -> Result<PathBuf, anyhow::Error> {
         use std::env::split_paths;
+        #[cfg(not(unix))]
+        use std::ffi::OsStr;
         #[cfg(unix)]
-        use std::os::unix::ffi::OsStrExt;
+        use std::ffi::OsString;
+        #[cfg(unix)]
+        use std::os::unix::ffi::OsStringExt;
         let path_var = std::env::var("PATH").unwrap_or_default();
         #[cfg(unix)]
         let system_path_var = std::process::Command::new("getconf")
             .args(["PATH"])
             .output()
-            .map(|output| output.stdout)
+            .map(|output| OsString::from_vec(output.stdout))
             .unwrap_or_default();
         let retval = if let Some(p) = path {
             if p.exists() {
@@ -1917,16 +1970,12 @@ pub(super) mod utils {
             }
         } else {
             let mut retval = None;
-            for mut p in split_paths(&path_var).chain(split_paths(
-                #[cfg(unix)]
-                {
-                    &OsStr::from_bytes(&system_path_var[..])
-                },
-                #[cfg(not(unix))]
-                {
-                    OsStr::new("")
-                },
-            )) {
+            #[cfg(unix)]
+            let combined_paths =
+                split_paths(&path_var).chain(split_paths(system_path_var.as_os_str()));
+            #[cfg(not(unix))]
+            let combined_paths = split_paths(&path_var).chain(split_paths(OsStr::new("")));
+            for mut p in combined_paths {
                 p.push(get_zig_exe_str());
                 if p.exists() {
                     retval = Some(p);
@@ -1960,7 +2009,10 @@ pub(super) mod utils {
             .map_err(|e| anyhow!("could not parse zig version: {version_slice}: {e}"))?;
 
         if version_semver < semver::Version::parse("0.10.0").unwrap() {
-            Err(anyhow!("`zig` binary in PATH (`{}`) is not a new enough version (`{version_slice}`): please use version `0.10.0` or newer.", retval.display()))
+            Err(anyhow!(
+                "`zig` binary in PATH (`{}`) is not a new enough version (`{version_slice}`): please use version `0.10.0` or newer.",
+                retval.display()
+            ))
         } else {
             Ok(retval)
         }
@@ -2095,7 +2147,7 @@ pub(super) mod utils {
 mod http_fetch {
     use std::path::Path;
 
-    use anyhow::{anyhow, Context, Result};
+    use anyhow::{Context, Result, anyhow};
 
     pub(super) fn get_release(
         release_version: Option<semver::Version>,
@@ -2120,6 +2172,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 +2227,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 +2273,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,15 +2285,16 @@ 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
             .split('/')
-            .last()
+            .next_back()
             .unwrap_or("output")
             .to_string();
 
@@ -2267,7 +2323,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 +2343,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 +2351,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 +2364,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..a7586a4fde 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
@@ -20,8 +21,8 @@ pub struct CreateObj {
     #[clap(name = "OUTPUT_PATH", short = 'o')]
     output: PathBuf,
 
-    /// Optional directorey used for debugging: if present, will
-    /// output the files to a debug instead of a temp directory
+    /// Optional directory used for debugging: if present, will
+    /// output the files to a debug instead of a temporary directory.
     #[clap(long, name = "DEBUG PATH")]
     debug_dir: Option<PathBuf>,
 
@@ -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..38763da7fe 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::{
+    Artifact, object::ObjectMetadataBuilder, types::symbols::ModuleMetadataSymbolRegistry,
 };
-use webc::{compat::SharedBytes, Container, DetectError};
+use wasmer_package::{package::WasmerPackageError, utils::from_bytes};
+use wasmer_types::target::{CpuFeature, Triple};
+use webc::{Container, ContainerError, DetectError, compat::SharedBytes};
 
-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,15 @@ 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 +102,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..0b12a7cc52 100644
--- a/lib/cli/src/commands/gen_completions.rs
+++ b/lib/cli/src/commands/gen_completions.rs
@@ -1,6 +1,6 @@
 use super::WasmerCmd;
 use clap::CommandFactory;
-use clap_complete::{generate, Shell};
+use clap_complete::{Shell, generate};
 use std::fs::OpenOptions;
 
 #[derive(Debug, Clone, clap::Parser)]
@@ -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..33fc7d771a 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(
@@ -542,7 +556,7 @@ fn parse_cargo_toml(manifest_path: &PathBuf) -> Result<MiniCargoTomlPackage, any
 
     Ok(MiniCargoTomlPackage {
         cargo_toml_path: manifest_path.clone(),
-        name: package.name.clone(),
+        name: package.name.as_str().to_owned(),
         version: package.version.clone(),
         description: package.description.clone(),
         homepage: package.homepage.clone(),
@@ -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..cfed9d991b 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,30 @@ impl Inspect {
     }
 
     fn inner_execute(&self) -> Result<()> {
-        let (store, _compiler_type) = self.store.get_store()?;
-
-        let module_contents = std::fs::read(&self.path)?;
+        let mut module_contents = std::fs::read(&self.path)?;
         let iswasm = is_wasm(&module_contents);
+
+        if !iswasm {
+            if self.path.extension().and_then(|e| e.to_str()) == Some("wat") {
+                module_contents = wat2wasm(&module_contents)
+                    .map_err(|e| anyhow::anyhow!("Cannot convert WAT to WASM: {e}"))?
+                    .to_vec();
+            } else {
+                anyhow::bail!("The input file is not a valid WebAssembly binary or WAT file");
+            }
+        }
+
+        let engine = self
+            .rt
+            .get_engine_for_module(&module_contents, &Target::default())?;
+
         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/compact.rs b/lib/cli/src/commands/journal/compact.rs
index 981d971ba5..034db1a3a9 100644
--- a/lib/cli/src/commands/journal/compact.rs
+++ b/lib/cli/src/commands/journal/compact.rs
@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use clap::Parser;
 use wasmer_wasix::journal::{
-    copy_journal, CompactingLogFileJournal, LogFileJournal, PrintingJournal,
+    CompactingLogFileJournal, LogFileJournal, PrintingJournal, copy_journal,
 };
 
 use crate::commands::CliCommand;
diff --git a/lib/cli/src/commands/journal/export.rs b/lib/cli/src/commands/journal/export.rs
index 7d94c7c698..6d76273c8c 100644
--- a/lib/cli/src/commands/journal/export.rs
+++ b/lib/cli/src/commands/journal/export.rs
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use clap::Parser;
-use wasmer_wasix::journal::{copy_journal, JournalPrintingMode, LogFileJournal, PrintingJournal};
+use wasmer_wasix::journal::{JournalPrintingMode, LogFileJournal, PrintingJournal, copy_journal};
 
 use crate::commands::CliCommand;
 
diff --git a/lib/cli/src/commands/journal/extract.rs b/lib/cli/src/commands/journal/extract.rs
index 20dd30c368..7f23c57358 100644
--- a/lib/cli/src/commands/journal/extract.rs
+++ b/lib/cli/src/commands/journal/extract.rs
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use clap::Parser;
-use wasmer_wasix::journal::{copy_journal, LogFileJournal};
+use wasmer_wasix::journal::{LogFileJournal, copy_journal};
 
 use crate::commands::CliCommand;
 
diff --git a/lib/cli/src/commands/journal/filter.rs b/lib/cli/src/commands/journal/filter.rs
index 4052067efd..ee045a5595 100644
--- a/lib/cli/src/commands/journal/filter.rs
+++ b/lib/cli/src/commands/journal/filter.rs
@@ -2,7 +2,7 @@ use std::{path::PathBuf, str::FromStr};
 
 use clap::Parser;
 use wasmer_wasix::journal::{
-    copy_journal, FilteredJournalBuilder, LogFileJournal, PrintingJournal,
+    FilteredJournalBuilder, LogFileJournal, PrintingJournal, copy_journal,
 };
 
 use crate::commands::CliCommand;
@@ -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/inspect.rs b/lib/cli/src/commands/journal/inspect.rs
index 9779e1f6f0..b92f54422e 100644
--- a/lib/cli/src/commands/journal/inspect.rs
+++ b/lib/cli/src/commands/journal/inspect.rs
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use clap::Parser;
-use wasmer_wasix::journal::{copy_journal, LogFileJournal, PrintingJournal};
+use wasmer_wasix::journal::{LogFileJournal, PrintingJournal, copy_journal};
 
 use crate::commands::CliCommand;
 
diff --git a/lib/cli/src/commands/journal/mod.rs b/lib/cli/src/commands/journal/mod.rs
index 44253cad52..cebcd054a6 100644
--- a/lib/cli/src/commands/journal/mod.rs
+++ b/lib/cli/src/commands/journal/mod.rs
@@ -6,8 +6,6 @@ mod extract;
 mod filter;
 mod import;
 mod inspect;
-#[cfg(feature = "fuse")]
-mod mount;
 
 pub use compact::*;
 pub use export::*;
@@ -15,8 +13,6 @@ pub use extract::*;
 pub use filter::*;
 pub use import::*;
 pub use inspect::*;
-#[cfg(feature = "fuse")]
-pub use mount::*;
 
 /// Manage Journal files.
 #[derive(clap::Subcommand, Debug)]
@@ -31,9 +27,6 @@ pub enum CmdJournal {
     Inspect(CmdJournalInspect),
     /// Filters out certain events from a journal
     Filter(CmdJournalFilter),
-    /// Mounts the journal at a particular directory
-    #[cfg(feature = "fuse")]
-    Mount(CmdJournalMount),
     /// Extracts an element of a journal
     Extract(CmdJournalExtract),
 }
@@ -48,8 +41,6 @@ impl CliCommand for CmdJournal {
             Self::Export(cmd) => cmd.run(),
             Self::Inspect(cmd) => cmd.run(),
             Self::Filter(cmd) => cmd.run(),
-            #[cfg(feature = "fuse")]
-            Self::Mount(cmd) => cmd.run(),
             Self::Extract(cmd) => cmd.run(),
         }
     }
diff --git a/lib/cli/src/commands/journal/mount/cmd.rs b/lib/cli/src/commands/journal/mount/cmd.rs
deleted file mode 100644
index 66d03f0e27..0000000000
--- a/lib/cli/src/commands/journal/mount/cmd.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use std::{path::PathBuf, process::Stdio};
-
-use clap::Parser;
-use wasmer_wasix::fs::WasiFdSeed;
-
-use super::fs::JournalFileSystemBuilder;
-use crate::commands::CliCommand;
-
-/// Mounts a journal as a file system on the local machine
-#[derive(Debug, Parser)]
-pub struct CmdJournalMount {
-    /// Path to the journal that will be printed
-    #[clap(index = 1)]
-    journal_path: PathBuf,
-    /// Path to the directory where the file system will be mounted
-    #[clap(index = 2)]
-    mount_path: PathBuf,
-}
-
-impl CliCommand for CmdJournalMount {
-    type Output = ();
-
-    fn run(self) -> Result<(), anyhow::Error> {
-        // First we unmount any existing file system on this path
-        std::process::Command::new("/bin/umount")
-            .arg(self.mount_path.to_string_lossy().as_ref())
-            .stderr(Stdio::null())
-            .stdout(Stdio::null())
-            .spawn()?
-            .wait()
-            .ok();
-
-        let fs = JournalFileSystemBuilder::new(&self.journal_path)
-            .with_fd_seed(WasiFdSeed::default())
-            .with_progress_bar(false)
-            .build()?;
-
-        // Mounts the journal file system at a path
-        fuse::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
deleted file mode 100644
index 5544eed0f5..0000000000
--- a/lib/cli/src/commands/journal/mount/fs.rs
+++ /dev/null
@@ -1,1220 +0,0 @@
-#![allow(unused)]
-use std::{
-    borrow::Cow,
-    collections::HashMap,
-    ffi::OsStr,
-    fs::File,
-    hash::{Hash, Hasher},
-    io,
-    path::{Path, PathBuf},
-    sync::{atomic::AtomicU32, Arc, Mutex},
-    time::Duration,
-};
-
-use fuse::{
-    FileAttr, Filesystem, ReplyAttr, ReplyBmap, ReplyCreate, ReplyData, ReplyDirectory, ReplyEmpty,
-    ReplyEntry, ReplyLock, ReplyOpen, ReplyStatfs, ReplyWrite, ReplyXattr, Request,
-};
-use indicatif::{ProgressBar, ProgressStyle};
-use shared_buffer::OwnedBuffer;
-use tokio::runtime::Handle;
-use virtual_fs::{
-    mem_fs::{self, OffloadBackingStore},
-    AsyncReadExt, AsyncSeekExt, AsyncWriteExt, FileOpener, FileSystem, FsError,
-};
-use wasmer_wasix::{
-    fs::WasiFdSeed,
-    journal::{
-        copy_journal, ArchivedJournalEntry, ArchivedJournalEntryFileDescriptorWriteV1, Journal,
-        JournalEntry, JournalEntryFileDescriptorWriteV1, LogFileJournal, LogWriteResult,
-        ReadableJournal, WritableJournal,
-    },
-    types::Oflags,
-    wasmer_wasix_types::wasi,
-    VIRTUAL_ROOT_FD,
-};
-
-#[derive(Debug)]
-struct State {
-    handle: tokio::runtime::Handle,
-    mem_fs: mem_fs::FileSystem,
-    inos: HashMap<u64, Cow<'static, str>>,
-    lookup: HashMap<
-        u32,
-        Arc<tokio::sync::Mutex<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>>>,
-    >,
-    seed: WasiFdSeed,
-    fake_offset: u64,
-}
-
-#[derive(Debug)]
-struct MutexState {
-    inner: Mutex<State>,
-}
-
-#[derive(Debug)]
-pub struct JournalFileSystemBuilder {
-    path: PathBuf,
-    fd_seed: WasiFdSeed,
-    progress_bar: bool,
-}
-
-impl JournalFileSystemBuilder {
-    pub fn new(path: &Path) -> Self {
-        Self {
-            path: path.to_path_buf(),
-            fd_seed: WasiFdSeed::default(),
-            progress_bar: false,
-        }
-    }
-
-    pub fn with_fd_seed(mut self, fd_seed: WasiFdSeed) -> Self {
-        self.fd_seed = fd_seed;
-        self
-    }
-
-    pub fn with_progress_bar(mut self, val: bool) -> Self {
-        self.progress_bar = val;
-        self
-    }
-
-    // Opens the journal and copies all its contents into
-    // and memory file system
-    pub fn build(self) -> anyhow::Result<JournalFileSystem> {
-        let journal = LogFileJournal::new(&self.path)?;
-        let backing_store = journal.backing_store();
-        let file_len = backing_store.owned_buffer().len();
-
-        let mem_fs = mem_fs::FileSystem::default().with_backing_offload(backing_store)?;
-        let state = MutexState {
-            inner: Mutex::new(State {
-                handle: tokio::runtime::Handle::current(),
-                mem_fs,
-                inos: Default::default(),
-                seed: self.fd_seed,
-                lookup: Default::default(),
-                fake_offset: 0,
-            }),
-        };
-
-        let progress = if self.progress_bar {
-            let mut pb = ProgressBar::new(file_len as u64);
-            pb.set_style(ProgressStyle::with_template("{msg}\n{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})")
-                .unwrap()
-                .progress_chars("#>-"));
-            pb.set_message("Loading journal...");
-
-            Some(pb)
-        } else {
-            None
-        };
-
-        tokio::task::block_in_place(|| {
-            if let Some(progress) = progress {
-                copy_journal_with_progress(&journal, &state, progress)
-            } else {
-                copy_journal(&journal, &state)
-            }
-        })?;
-
-        let ret = JournalFileSystem {
-            handle: tokio::runtime::Handle::current(),
-            journal,
-            state,
-        };
-
-        Ok(ret)
-    }
-}
-
-pub fn copy_journal_with_progress<R: ReadableJournal, W: WritableJournal>(
-    from: &R,
-    to: &W,
-    mut progress: ProgressBar,
-) -> anyhow::Result<()> {
-    while let Some(record) = from.read()? {
-        progress.set_position(record.record_end);
-        to.write(record.into_inner())?;
-    }
-    progress.finish_and_clear();
-    println!("Journal is mounted");
-    Ok(())
-}
-
-#[derive(Debug)]
-pub struct JournalFileSystem {
-    handle: tokio::runtime::Handle,
-    journal: LogFileJournal,
-    state: MutexState,
-}
-
-impl JournalFileSystem {
-    fn reverse_ino(&self, ino: u64) -> Result<Cow<'static, str>, libc::c_int> {
-        if ino == 1 {
-            return Ok("/".into());
-        }
-        let path = {
-            let mut state = self.state.inner.lock().unwrap();
-            match state.inos.get(&ino).cloned() {
-                Some(path) => path,
-                None => {
-                    return Err(libc::ENOENT);
-                }
-            }
-        };
-        Ok(path)
-    }
-
-    fn attr<'a>(&self, path: Cow<'a, str>) -> Result<FileAttr, libc::c_int> {
-        let mut state = self.state.inner.lock().unwrap();
-
-        let res = state.mem_fs.metadata(&Path::new(path.as_ref()));
-        match res {
-            Ok(meta) => {
-                // The ino is just the hash of the name
-                let mut hasher = std::collections::hash_map::DefaultHasher::new();
-                path.hash(&mut hasher);
-                let ino = hasher.finish();
-                state
-                    .inos
-                    .entry(ino)
-                    .or_insert_with(|| path.into_owned().into());
-
-                // Build a file attr and return it
-                Ok(FileAttr {
-                    ino,
-                    size: meta.len,
-                    blocks: (1u64.max(meta.len) - 1 / 512) + 1,
-                    atime: time01::Timespec::new(meta.accessed as i64, 0),
-                    mtime: time01::Timespec::new(meta.modified as i64, 0),
-                    ctime: time01::Timespec::new(meta.created as i64, 0),
-                    crtime: time01::Timespec::new(meta.created as i64, 0),
-                    kind: file_type_to_kind(meta.ft),
-                    perm: 0o644,
-                    nlink: 1,
-                    uid: 0,
-                    gid: 0,
-                    rdev: 0,
-                    flags: 0,
-                })
-            }
-            Err(FsError::EntryNotFound) => Err(libc::ENOENT),
-            Err(_) => Err(libc::EIO),
-        }
-    }
-}
-
-impl WritableJournal for MutexState {
-    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
-        let mut state = self.inner.lock().unwrap();
-        let ret = LogWriteResult {
-            record_start: state.fake_offset,
-            record_end: state.fake_offset + entry.estimate_size() as u64,
-        };
-        state.fake_offset += ret.record_size();
-        match entry {
-            JournalEntry::FileDescriptorWriteV1 {
-                fd,
-                offset,
-                data,
-                is_64bit,
-            } => {
-                let handle = state.handle.clone();
-                if let Some(file) = state.lookup.get_mut(&fd) {
-                    handle.block_on(async {
-                        let mut file = file.lock().await;
-                        file.seek(io::SeekFrom::Start(offset)).await;
-                        file.write_all(&data).await
-                    })?;
-                }
-            }
-            JournalEntry::CloseFileDescriptorV1 { fd } => {
-                state.lookup.remove(&fd);
-            }
-            JournalEntry::OpenFileDescriptorV1 {
-                fd,
-                dirfd,
-                dirflags,
-                path,
-                o_flags,
-                fs_rights_base,
-                fs_rights_inheriting,
-                fs_flags,
-            } => {
-                state.seed.clip_val(fd + 1);
-                let file = state
-                    .mem_fs
-                    .new_open_options()
-                    .create(o_flags.contains(Oflags::CREATE))
-                    .truncate(o_flags.contains(Oflags::TRUNC))
-                    .write(true)
-                    .read(true)
-                    .open(path.as_ref())?;
-                state
-                    .lookup
-                    .insert(fd, Arc::new(tokio::sync::Mutex::new(file)));
-            }
-            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
-                state.seed.clip_val(new_fd + 1);
-                if let Some(file) = state.lookup.remove(&old_fd) {
-                    state.lookup.insert(new_fd, file);
-                }
-            }
-            JournalEntry::DuplicateFileDescriptorV1 {
-                original_fd,
-                copied_fd,
-            } => {
-                state.seed.clip_val(copied_fd + 1);
-                if let Some(file) = state.lookup.get(&original_fd).cloned() {
-                    state.lookup.insert(copied_fd, file);
-                }
-            }
-            JournalEntry::CreateDirectoryV1 { fd, path } => {
-                state.mem_fs.create_dir(&Path::new(path.as_ref())).ok();
-            }
-            JournalEntry::RemoveDirectoryV1 { fd, path } => {
-                state.mem_fs.remove_dir(&Path::new(path.as_ref()))?;
-            }
-            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
-                let handle = state.handle.clone();
-                if let Some(file) = state.lookup.get(&fd) {
-                    handle.block_on(async {
-                        let mut file = file.lock().await;
-                        file.set_len(st_size)
-                    })?;
-                }
-            }
-            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
-                let handle = state.handle.clone();
-                if let Some(file) = state.lookup.get(&fd) {
-                    handle.block_on(async {
-                        let mut file = file.lock().await;
-                        file.set_len(offset + len)
-                    })?;
-                }
-            }
-            JournalEntry::UnlinkFileV1 { fd, path } => {
-                state.mem_fs.remove_file(&Path::new(path.as_ref()))?;
-            }
-            JournalEntry::PathRenameV1 {
-                old_fd,
-                old_path,
-                new_fd,
-                new_path,
-            } => {
-                let handle = state.handle.clone();
-                handle.block_on(async {
-                    state
-                        .mem_fs
-                        .rename(&Path::new(old_path.as_ref()), &Path::new(new_path.as_ref()))
-                        .await
-                })?;
-            }
-            JournalEntry::SocketOpenV1 { fd, .. } => {
-                state.seed.clip_val(fd + 1);
-            }
-            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
-                state.seed.clip_val(fd1 + 1);
-                state.seed.clip_val(fd2 + 1);
-            }
-            JournalEntry::CreateEventV1 { fd, .. } => {
-                state.seed.clip_val(fd + 1);
-            }
-            JournalEntry::EpollCreateV1 { fd } => {
-                state.seed.clip_val(fd + 1);
-            }
-            JournalEntry::EpollCtlV1 {
-                epfd,
-                op,
-                fd,
-                event,
-            } => {
-                state.seed.clip_val(fd + 1);
-            }
-            JournalEntry::SocketAcceptedV1 { fd, .. } => {
-                state.seed.clip_val(fd + 1);
-            }
-            _ => {}
-        }
-        Ok(ret)
-    }
-
-    fn flush(&self) -> anyhow::Result<()> {
-        let mut state = self.inner.lock().unwrap();
-        state.mem_fs.flush()?;
-        Ok(())
-    }
-}
-
-impl JournalFileSystem {
-    fn compute_path<'a>(&'a self, parent: u64, name: &'a OsStr) -> Result<Cow<'_, str>, i32> {
-        // Get the path from the ino otherwise it is not a known
-        // path (this means the other methods have to be hit first)
-        let path = match self.reverse_ino(parent) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::compute_path reverse_ino({parent}) errno={err}");
-                return Err(err);
-            }
-        };
-
-        // Add the name as a postfix
-        let name = name.to_string_lossy();
-        let path = if path.ends_with("/") {
-            path + name
-        } else {
-            path + "/" + name
-        };
-        Ok(path)
-    }
-}
-
-impl Filesystem for JournalFileSystem {
-    fn init(&mut self, _req: &Request) -> Result<(), libc::c_int> {
-        Ok(())
-    }
-
-    fn destroy(&mut self, _req: &Request) {}
-
-    fn lookup(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEntry) {
-        let path = match self.compute_path(parent, name) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::lookup err={err}");
-                return reply.error(err);
-            }
-        };
-
-        match self.attr(path) {
-            Ok(meta) => reply.entry(&time01::Timespec::new(1, 0), &meta, 0),
-            Err(err) => {
-                tracing::trace!("fs::lookup err={err}");
-                reply.error(err)
-            }
-        }
-    }
-
-    fn getattr(&mut self, _req: &Request, ino: u64, reply: ReplyAttr) {
-        let path = match self.reverse_ino(ino) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::getattr reverse_ino({ino}) errno={err}");
-                reply.error(err);
-                return;
-            }
-        };
-
-        match self.attr(path) {
-            Ok(meta) => reply.attr(&time01::Timespec::new(1, 0), &meta),
-            Err(err) => reply.error(err),
-        }
-    }
-
-    fn setattr(
-        &mut self,
-        _req: &Request,
-        ino: u64,
-        _mode: Option<u32>,
-        _uid: Option<u32>,
-        _gid: Option<u32>,
-        size: Option<u64>,
-        _atime: Option<time01::Timespec>,
-        _mtime: Option<time01::Timespec>,
-        fh: Option<u64>,
-        _crtime: Option<time01::Timespec>,
-        _chgtime: Option<time01::Timespec>,
-        _bkuptime: Option<time01::Timespec>,
-        _flags: Option<u32>,
-        reply: ReplyAttr,
-    ) {
-        let mut entries = Vec::new();
-
-        let attr = match fh {
-            Some(fd) => {
-                let fd = fd as u32;
-                let mut state = self.state.inner.lock().unwrap();
-                let file = match state.lookup.get_mut(&fd) {
-                    Some(f) => f.clone(),
-                    None => {
-                        tracing::trace!("fs::getattr noent (fd={fd})");
-                        reply.error(libc::ENOENT);
-                        return;
-                    }
-                };
-
-                self.handle.block_on(async {
-                    let mut file = file.lock().await;
-
-                    if let Some(size) = size {
-                        entries.push(JournalEntry::FileDescriptorSetSizeV1 {
-                            fd: fd as u32,
-                            st_size: size,
-                        })
-                    }
-
-                    FileAttr {
-                        ino,
-                        size: file.size(),
-                        blocks: (1u64.max(file.size()) - 1 / 512) + 1,
-                        atime: time01::Timespec::new(file.last_accessed() as i64, 0),
-                        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,
-                        perm: 0o644,
-                        nlink: 1,
-                        uid: 0,
-                        gid: 0,
-                        rdev: 0,
-                        flags: 0,
-                    }
-                })
-            }
-            None => {
-                let path = match self.reverse_ino(ino) {
-                    Ok(a) => a,
-                    Err(err) => {
-                        tracing::trace!("fs::setattr reverse_ino({ino}) errno={err}");
-                        reply.error(err);
-                        return;
-                    }
-                };
-
-                let fh;
-                let mut state = self.state.inner.lock().unwrap();
-                let file = state
-                    .mem_fs
-                    .new_open_options()
-                    .read(true)
-                    .write(true)
-                    .open(&Path::new(path.as_ref()));
-                match file {
-                    Ok(file) => {
-                        // Reserve a file descriptor and close the state
-                        fh = state.seed.next_val();
-                        drop(state);
-
-                        entries.push(JournalEntry::OpenFileDescriptorV1 {
-                            fd: fh,
-                            dirfd: VIRTUAL_ROOT_FD,
-                            dirflags: 0,
-                            path,
-                            o_flags: wasi::Oflags::empty(),
-                            fs_rights_base: wasi::Rights::all(),
-                            fs_rights_inheriting: wasi::Rights::all(),
-                            fs_flags: wasi::Fdflags::empty(),
-                        });
-                        if let Some(size) = size {
-                            entries.push(JournalEntry::FileDescriptorSetSizeV1 {
-                                fd: fh as u32,
-                                st_size: size,
-                            })
-                        }
-                        entries.push(JournalEntry::CloseFileDescriptorV1 { fd: fh });
-
-                        for entry in entries.iter() {
-                            if self.state.write(entry.clone()).is_err() {
-                                tracing::trace!("fs::open err=EIO");
-                                reply.error(libc::EIO);
-                                return;
-                            }
-                        }
-                        for entry in entries.iter() {
-                            if self.journal.write(entry.clone()).is_err() {
-                                tracing::trace!("fs::open err=EIO");
-                                reply.error(libc::EIO);
-                                return;
-                            }
-                        }
-                        FileAttr {
-                            ino,
-                            size: file.size(),
-                            blocks: (1u64.max(file.size()) - 1 / 512) + 1,
-                            atime: time01::Timespec::new(file.last_accessed() as i64, 0),
-                            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,
-                            perm: 0o644,
-                            nlink: 1,
-                            uid: 0,
-                            gid: 0,
-                            rdev: 0,
-                            flags: 0,
-                        }
-                    }
-                    Err(FsError::EntryNotFound) => {
-                        // Maybe its a directory, in which case we are done
-                        if let Ok(meta) = state.mem_fs.metadata(&Path::new(path.as_ref())) {
-                            FileAttr {
-                                ino,
-                                size: meta.len,
-                                blocks: (1u64.max(meta.len) - 1 / 512) + 1,
-                                atime: time01::Timespec::new(meta.accessed as i64, 0),
-                                mtime: time01::Timespec::new(meta.modified as i64, 0),
-                                ctime: time01::Timespec::new(meta.created as i64, 0),
-                                crtime: time01::Timespec::new(meta.created as i64, 0),
-                                kind: file_type_to_kind(meta.ft),
-                                perm: 0o644,
-                                nlink: 1,
-                                uid: 0,
-                                gid: 0,
-                                rdev: 0,
-                                flags: 0,
-                            }
-                        } else {
-                            tracing::trace!("fs::setattr open_file({path}) err=ENOENT");
-                            reply.error(libc::ENOENT);
-                            return;
-                        }
-                    }
-                    Err(err) => {
-                        tracing::trace!("fs::setattr open_file({path}) err={err}");
-                        reply.error(libc::EIO);
-                        return;
-                    }
-                }
-            }
-        };
-
-        // Return the data
-        reply.attr(&time01::Timespec::new(1, 0), &attr)
-    }
-
-    fn setxattr(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _name: &OsStr,
-        _value: &[u8],
-        _flags: u32,
-        _position: u32,
-        reply: ReplyEmpty,
-    ) {
-        tracing::trace!("fs::setxattr err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn getxattr(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _name: &OsStr,
-        _size: u32,
-        reply: ReplyXattr,
-    ) {
-        tracing::trace!("fs::getxattr size(0)");
-        reply.size(0)
-    }
-
-    fn open(&mut self, _req: &Request, ino: u64, flags: u32, reply: ReplyOpen) {
-        let path = match self.reverse_ino(ino) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::open reverse_ino({ino}) errno={err}");
-                reply.error(err);
-                return;
-            }
-        };
-
-        // Reserve a file descriptor
-        let fh = {
-            let mut state = self.state.inner.lock().unwrap();
-            state.seed.next_val()
-        };
-
-        // Write the journals
-        let entry = JournalEntry::OpenFileDescriptorV1 {
-            fd: fh,
-            dirfd: VIRTUAL_ROOT_FD,
-            dirflags: 0,
-            path,
-            o_flags: wasi::Oflags::empty(),
-            fs_rights_base: wasi::Rights::all(),
-            fs_rights_inheriting: wasi::Rights::all(),
-            fs_flags: wasi::Fdflags::empty(),
-        };
-        if self.state.write(entry.clone()).is_err() {
-            tracing::trace!("fs::open err=EIO");
-            reply.error(libc::EIO);
-            return;
-        }
-        if self.journal.write(entry).is_err() {
-            tracing::trace!("fs::open err=EIO");
-            reply.error(libc::EIO);
-            return;
-        }
-
-        tracing::trace!("fs::open opened fh={fh}");
-        reply.opened(fh as u64, flags);
-    }
-
-    fn release(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        fh: u64,
-        _flags: u32,
-        _lock_owner: u64,
-        _flush: bool,
-        reply: ReplyEmpty,
-    ) {
-        let fh = fh as u32;
-
-        {
-            // Check that the file handle exists
-            let mut state = self.state.inner.lock().unwrap();
-            if !state.lookup.contains_key(&fh) {
-                tracing::trace!("fs::release err=ENOENT (fd={fh})");
-                reply.error(libc::ENOENT);
-                return;
-            }
-        }
-
-        // Write the journals
-        let entry = JournalEntry::CloseFileDescriptorV1 { fd: fh };
-        if self.state.write(entry.clone()).is_err() {
-            tracing::trace!("fs::release err=EIO");
-            reply.error(libc::EIO);
-            return;
-        }
-        if self.journal.write(entry).is_err() {
-            tracing::trace!("fs::release err=EIO");
-            reply.error(libc::EIO);
-            return;
-        }
-
-        tracing::trace!("fs::release ok");
-        reply.ok();
-    }
-
-    fn create(
-        &mut self,
-        _req: &Request,
-        parent: u64,
-        name: &OsStr,
-        mode: u32,
-        flags: u32,
-        reply: ReplyCreate,
-    ) {
-        let path = match self.compute_path(parent, name) {
-            Ok(a) => a,
-            Err(err) => return reply.error(err),
-        };
-
-        // The ino is just the hash of the name
-        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        path.hash(&mut hasher);
-        let ino = hasher.finish();
-
-        // Reserve a file descriptor
-        let fh = {
-            let mut state = self.state.inner.lock().unwrap();
-            state.seed.next_val()
-        };
-
-        // Write the journals
-        let entry = JournalEntry::OpenFileDescriptorV1 {
-            fd: fh,
-            dirfd: VIRTUAL_ROOT_FD,
-            dirflags: 0,
-            path,
-            o_flags: wasi::Oflags::CREATE,
-            fs_rights_base: wasi::Rights::all(),
-            fs_rights_inheriting: wasi::Rights::all(),
-            fs_flags: wasi::Fdflags::empty(),
-        };
-        if let Err(err) = self.state.write(entry.clone()) {
-            tracing::trace!("fs::create (j1) err=EIO - {err}");
-            reply.error(libc::EIO);
-            return;
-        }
-        if let Err(err) = self.journal.write(entry) {
-            tracing::trace!("fs::create (j2) err=EIO - {err}");
-            reply.error(libc::EIO);
-            return;
-        }
-
-        let now = time01::get_time();
-        reply.created(
-            &time01::Timespec::new(1, 0),
-            &FileAttr {
-                ino,
-                size: 0,
-                blocks: 0,
-                atime: now,
-                mtime: now,
-                ctime: now,
-                crtime: now,
-                kind: fuse::FileType::RegularFile,
-                perm: 0o644,
-                nlink: 1,
-                uid: 0,
-                gid: 0,
-                rdev: 0,
-                flags: 0,
-            },
-            0,
-            fh as u64,
-            flags,
-        );
-    }
-
-    fn read(
-        &mut self,
-        _req: &Request,
-        ino: u64,
-        fh: u64,
-        offset: i64,
-        size: u32,
-        reply: ReplyData,
-    ) {
-        let fh = fh as u32;
-
-        // Grab the file from the file handle
-        let mut state = self.state.inner.lock().unwrap();
-        let file = match state.lookup.get_mut(&fh) {
-            Some(a) => a,
-            None => {
-                tracing::trace!("fs::read lookup(fh={fh}) noent err=EIO");
-                reply.error(libc::ENOENT);
-                return;
-            }
-        };
-
-        // Read the data from the file and return it
-        let data: Result<_, io::Error> = self.handle.block_on(async {
-            let mut file = file.lock().await;
-
-            let mut buf = Vec::with_capacity(size as usize);
-            unsafe { buf.set_len(size as usize) };
-            file.seek(io::SeekFrom::Start(offset as u64)).await?;
-            let amt = file.read(&mut buf).await?;
-            unsafe { buf.set_len(amt) };
-            Ok(buf)
-        });
-        let data = match data {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::read data err=EIO");
-                reply.error(libc::EIO);
-                return;
-            }
-        };
-
-        // Return the data
-        reply.data(&data);
-    }
-
-    fn write(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        fh: u64,
-        offset: i64,
-        data: &[u8],
-        _flags: u32,
-        reply: ReplyWrite,
-    ) {
-        let fh = fh as u32;
-
-        {
-            // Check that the file handle exists
-            let mut state = self.state.inner.lock().unwrap();
-            if !state.lookup.contains_key(&fh) {
-                tracing::trace!("fs::write err=ENOENT");
-                reply.error(libc::ENOENT);
-                return;
-            }
-        }
-
-        // Write the entry to the log file
-        let fd = fh as u32;
-        let entry = JournalEntry::FileDescriptorWriteV1 {
-            fd,
-            offset: offset as u64,
-            data: data.into(),
-            is_64bit: false,
-        };
-
-        let res = match self.journal.write(entry) {
-            Ok(res) => res,
-            Err(err) => {
-                tracing::trace!("fs::write err=EIO - {err}");
-                reply.error(libc::EIO);
-                return;
-            }
-        };
-
-        // We load the record from the journal and use this to write to the memory file system
-        // because the memory file system has an optimization where it will automatically offload
-        // the data to the mmap of the journal rather than store it in memory. In effect it offloads
-        // to the disk
-        {
-            let mut state = self.state.inner.lock().unwrap();
-            let handle = state.handle.clone();
-            if let Some(file) = state.lookup.get_mut(&fd) {
-                let res: Result<_, io::Error> = handle.block_on(async {
-                    let mut file = file.lock().await;
-                    file.seek(io::SeekFrom::Start(offset as u64)).await;
-
-                    // Unsafe!!! This assumes the structure does not change
-                    // where the first bytes in the entry are an aligned
-                    // array that corresponds to the data itself
-                    let size = data.len() as u64;
-                    let mut mmap_offset = res.record_start;
-                    let align = mmap_offset % 16;
-                    if align != 0 {
-                        mmap_offset += 16 - align;
-                    }
-
-                    // Add the entry
-                    if file.write_from_mmap(mmap_offset, size).is_err() {
-                        // We fall back on just writing the data normally
-                        file.seek(io::SeekFrom::Start(offset as u64)).await;
-                        file.write_all(&data).await?;
-                    }
-                    Ok(())
-                });
-                if let Err(err) = res {
-                    tracing::trace!("fs::write err=EIO");
-                    reply.error(libc::EIO);
-                    return;
-                }
-            } else {
-                tracing::trace!("fs::write err=EIO");
-                reply.error(libc::EIO);
-                return;
-            }
-        }
-
-        reply.written(data.len() as u32);
-    }
-
-    fn readdir(
-        &mut self,
-        _req: &Request,
-        ino: u64,
-        _fh: u64,
-        offset: i64,
-        mut reply: ReplyDirectory,
-    ) {
-        // Get the path from the ino otherwise it is not a known
-        // path (this means the other methods have to be hit first)
-        let path = match self.reverse_ino(ino) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::readir reverse_ino({ino}) err={}", err);
-                reply.error(err);
-                return;
-            }
-        };
-
-        let mut state = self.state.inner.lock().unwrap();
-        let read_dir = state.mem_fs.read_dir(&Path::new(path.as_ref()));
-        let read_dir = match read_dir {
-            Ok(a) => a,
-            Err(FsError::EntryNotFound) => {
-                tracing::trace!("fs::readir read_dir({}) err=ENOENT", path);
-                return;
-            }
-            Err(err) => {
-                tracing::trace!("fs::readir read_dir({}) err={}", path, err);
-                reply.error(libc::EIO);
-                return;
-            }
-        };
-
-        for (i, entry) in read_dir.into_iter().enumerate().skip(offset as usize) {
-            let entry = match entry {
-                Ok(a) => a,
-                Err(err) => {
-                    tracing::trace!("fs::readir direntry(index={i}) err={}", err);
-                    reply.error(libc::EIO);
-                    return;
-                }
-            };
-            let path = entry.path.to_string_lossy();
-            let name = match entry.path.file_name() {
-                Some(n) => n,
-                None => {
-                    tracing::trace!("fs::readir file_name err=EIO");
-                    reply.error(libc::EIO);
-                    return;
-                }
-            };
-
-            // The ino is just the hash of the name
-            let mut hasher = std::collections::hash_map::DefaultHasher::new();
-            path.hash(&mut hasher);
-            let ino = hasher.finish();
-            state
-                .inos
-                .entry(ino)
-                .or_insert_with(|| path.into_owned().into());
-
-            // Compute the directory kind
-            let kind = match entry.file_type() {
-                Ok(ft) => file_type_to_kind(ft),
-                _ => fuse::FileType::RegularFile,
-            };
-
-            // i + 1 means the index of the next entry
-            reply.add(ino, (i + 1) as i64, kind, name);
-        }
-        reply.ok();
-    }
-
-    fn mkdir(&mut self, _req: &Request, parent: u64, name: &OsStr, _mode: u32, reply: ReplyEntry) {
-        let path = match self.compute_path(parent, name) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::mkdir compute_path err={err}");
-                return reply.error(err);
-            }
-        };
-
-        let entry = JournalEntry::CreateDirectoryV1 {
-            fd: VIRTUAL_ROOT_FD,
-            path: path.clone(),
-        };
-        self.state.write(entry.clone());
-        self.journal.write(entry);
-
-        match self.attr(path) {
-            Ok(meta) => {
-                tracing::trace!("fs::mkdir ok");
-                reply.entry(&time01::Timespec::new(1, 0), &meta, 0)
-            }
-            Err(err) => {
-                tracing::trace!("fs::mkdir attr err={err}");
-                reply.error(err)
-            }
-        }
-    }
-
-    fn rmdir(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEmpty) {
-        let path = match self.compute_path(parent, name) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::rmdir err={err}");
-                return reply.error(err);
-            }
-        };
-
-        let entry = JournalEntry::RemoveDirectoryV1 {
-            fd: VIRTUAL_ROOT_FD,
-            path: path.clone(),
-        };
-        self.state.write(entry.clone());
-        self.journal.write(entry);
-        tracing::trace!("fs::rmdir ok");
-        reply.ok();
-    }
-
-    fn unlink(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEmpty) {
-        let path = match self.compute_path(parent, name) {
-            Ok(a) => a,
-            Err(err) => {
-                tracing::trace!("fs::unlink err={err}");
-                return reply.error(err);
-            }
-        };
-
-        let entry = JournalEntry::UnlinkFileV1 {
-            fd: VIRTUAL_ROOT_FD,
-            path: path.clone(),
-        };
-        self.state.write(entry.clone());
-        self.journal.write(entry);
-        tracing::trace!("fs::unlink ok");
-        reply.ok();
-    }
-
-    fn forget(&mut self, _req: &Request, _ino: u64, _nlookup: u64) {
-        tracing::trace!("fs::forget ok");
-    }
-
-    fn readlink(&mut self, _req: &Request, _ino: u64, reply: ReplyData) {
-        tracing::trace!("fs::readlink err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn mknod(
-        &mut self,
-        _req: &Request,
-        _parent: u64,
-        _name: &OsStr,
-        _mode: u32,
-        _rdev: u32,
-        reply: ReplyEntry,
-    ) {
-        tracing::trace!("fs::mknod err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn symlink(
-        &mut self,
-        _req: &Request,
-        _parent: u64,
-        _name: &OsStr,
-        _link: &Path,
-        reply: ReplyEntry,
-    ) {
-        tracing::trace!("fs::symlink err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn rename(
-        &mut self,
-        _req: &Request,
-        _parent: u64,
-        _name: &OsStr,
-        _newparent: u64,
-        _newname: &OsStr,
-        reply: ReplyEmpty,
-    ) {
-        tracing::trace!("fs::rename err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn link(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _newparent: u64,
-        _newname: &OsStr,
-        reply: ReplyEntry,
-    ) {
-        tracing::trace!("fs::link err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn fsync(&mut self, _req: &Request, _ino: u64, _fh: u64, _datasync: bool, reply: ReplyEmpty) {
-        tracing::trace!("fs::fsync err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn opendir(&mut self, _req: &Request, _ino: u64, _flags: u32, reply: ReplyOpen) {
-        tracing::trace!("fs::opendir opened");
-        reply.opened(0, 0);
-    }
-
-    fn releasedir(&mut self, _req: &Request, _ino: u64, _fh: u64, _flags: u32, reply: ReplyEmpty) {
-        tracing::trace!("fs::releasedir ok");
-        reply.ok();
-    }
-
-    fn fsyncdir(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _fh: u64,
-        _datasync: bool,
-        reply: ReplyEmpty,
-    ) {
-        tracing::trace!("fs::fsyncdir err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn statfs(&mut self, _req: &Request, _ino: u64, reply: ReplyStatfs) {
-        tracing::trace!("fs::statfs ok");
-        reply.statfs(0, 0, 0, 0, 0, 512, 255, 0);
-    }
-
-    fn listxattr(&mut self, _req: &Request, _ino: u64, _size: u32, reply: ReplyXattr) {
-        tracing::trace!("fs::listxattr err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn removexattr(&mut self, _req: &Request, _ino: u64, _name: &OsStr, reply: ReplyEmpty) {
-        tracing::trace!("fs::removexattr err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn access(&mut self, _req: &Request, _ino: u64, _mask: u32, reply: ReplyEmpty) {
-        tracing::trace!("fs::access err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn getlk(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _fh: u64,
-        _lock_owner: u64,
-        _start: u64,
-        _end: u64,
-        _typ: u32,
-        _pid: u32,
-        reply: ReplyLock,
-    ) {
-        tracing::trace!("fs::getlk err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn setlk(
-        &mut self,
-        _req: &Request,
-        _ino: u64,
-        _fh: u64,
-        _lock_owner: u64,
-        _start: u64,
-        _end: u64,
-        _typ: u32,
-        _pid: u32,
-        _sleep: bool,
-        reply: ReplyEmpty,
-    ) {
-        tracing::trace!("fs::setlk err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    fn bmap(&mut self, _req: &Request, _ino: u64, _blocksize: u32, _idx: u64, reply: ReplyBmap) {
-        tracing::trace!("fs::bmp err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    #[cfg(target_os = "macos")]
-    fn setvolname(&mut self, _req: &Request, _name: &OsStr, reply: ReplyEmpty) {
-        tracing::trace!("fs::setvolname err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    #[cfg(target_os = "macos")]
-    fn exchange(
-        &mut self,
-        _req: &Request,
-        _parent: u64,
-        _name: &OsStr,
-        _newparent: u64,
-        _newname: &OsStr,
-        _options: u64,
-        reply: ReplyEmpty,
-    ) {
-        tracing::trace!("fs::exchange err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-
-    #[cfg(target_os = "macos")]
-    fn getxtimes(&mut self, _req: &Request, _ino: u64, reply: ReplyXTimes) {
-        tracing::trace!("fs::getxtimes err=ENOSYS");
-        reply.error(libc::ENOSYS);
-    }
-}
-
-fn file_type_to_kind(ft: virtual_fs::FileType) -> fuse::FileType {
-    if ft.dir {
-        fuse::FileType::Directory
-    } else if ft.symlink {
-        fuse::FileType::Symlink
-    } else if ft.block_device {
-        fuse::FileType::BlockDevice
-    } else if ft.char_device {
-        fuse::FileType::CharDevice
-    } else if ft.socket {
-        fuse::FileType::Socket
-    } else {
-        fuse::FileType::RegularFile
-    }
-}
diff --git a/lib/cli/src/commands/journal/mount/mod.rs b/lib/cli/src/commands/journal/mount/mod.rs
deleted file mode 100644
index 44c28850b1..0000000000
--- a/lib/cli/src/commands/journal/mount/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod cmd;
-mod fs;
-
-pub use cmd::*;
diff --git a/lib/cli/src/commands/mod.rs b/lib/cli/src/commands/mod.rs
index 5b56d25b08..ee0125ba8d 100644
--- a/lib/cli/src/commands/mod.rs
+++ b/lib/cli/src/commands/mod.rs
@@ -31,7 +31,8 @@ pub mod ssh;
 mod validate;
 #[cfg(feature = "wast")]
 mod wast;
-use std::env::args;
+use std::ffi::OsString;
+use std::io::IsTerminal as _;
 use tokio::task::JoinHandle;
 
 #[cfg(target_os = "linux")]
@@ -44,6 +45,7 @@ pub use create_exe::*;
 #[cfg(feature = "wast")]
 pub use wast::*;
 #[cfg(feature = "static-artifact-create")]
+#[allow(unused_imports)]
 pub use {create_obj::*, gen_c_header::*};
 
 #[cfg(feature = "journal")]
@@ -53,6 +55,7 @@ pub use self::{
     publish::*, run::Run, self_update::*, validate::*,
 };
 use crate::error::PrettyError;
+use git_version::git_version;
 
 /// An executable CLI command.
 pub(crate) trait CliCommand {
@@ -75,7 +78,7 @@ pub(crate) trait AsyncCliCommand: Send + Sync {
         &self,
         done: tokio::sync::oneshot::Receiver<()>,
     ) -> Option<JoinHandle<anyhow::Result<()>>> {
-        if is_terminal::IsTerminal::is_terminal(&std::io::stdin()) {
+        if std::io::stdin().is_terminal() {
             return Some(tokio::task::spawn(async move {
                 tokio::select! {
                     _ = done => {}
@@ -177,13 +180,14 @@ impl WasmerCmd {
             Some(Cmd::Validate(validate)) => validate.execute(),
             #[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(),
-            #[cfg(feature = "static-artifact-create")]
-            Some(Cmd::CreateObj(create_obj)) => create_obj.execute(),
-            Some(Cmd::Config(config)) => config.execute(),
+            // CreateExe and CreateObj commands are temporarily disabled
+            // #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+            // 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.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 +202,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 +209,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(),
@@ -236,14 +237,61 @@ impl WasmerCmd {
     }
 
     fn run_inner() -> Result<(), anyhow::Error> {
+        let mut args_os = std::env::args_os();
+
+        let args = args_os.next().into_iter();
+
+        let mut binfmt_args: Vec<OsString> = Vec::new();
         if is_binfmt_interpreter() {
-            Run::from_binfmt_args().execute(crate::logging::Output::default());
-        }
+            // In case of binfmt misc the first argument is wasmer-binfmt-interpreter, the second is the full path to the executable
+            // and the third is the original string for the executable as originally called by the user.
+
+            // For now we are only using the real path and ignoring the original executable name.
+            // Ideally we would use the real path to load the file and the original name to pass it as argv[0] to the wasm module.
+
+            let current_dir = std::env::current_dir()
+                .unwrap()
+                .into_os_string()
+                .into_string()
+                .unwrap();
+            let mut mount_paths = vec!["/home", "/etc", "/tmp", "/var", "/nix", "/opt", "/root"]
+                .into_iter()
+                .filter(|path| {
+                    let path = std::path::Path::new(path);
+                    if !path.is_dir() {
+                        // Not a directory
+                        return false;
+                    }
+                    if std::fs::read_dir(path).is_err() {
+                        // No permissions
+                        return false;
+                    }
+                    true
+                })
+                .collect::<Vec<_>>();
+            if !current_dir.starts_with("/home") {
+                mount_paths.push(current_dir.as_str());
+            }
 
-        match WasmerCmd::try_parse() {
+            binfmt_args.push("run".into());
+            binfmt_args.push("--net".into());
+            // TODO: This does not seem to work, needs further investigation.
+            binfmt_args.push("--forward-host-env".into());
+            for mount_path in mount_paths {
+                binfmt_args.push(format!("--mapdir={mount_path}:{mount_path}").into());
+            }
+            binfmt_args.push(format!("--cwd={current_dir}").into());
+            binfmt_args.push("--quiet".into());
+            binfmt_args.push("--".into());
+            binfmt_args.push(args_os.next().unwrap());
+            args_os.next().unwrap();
+        };
+        let args_vec = args.chain(binfmt_args).chain(args_os).collect::<Vec<_>>();
+
+        match WasmerCmd::try_parse_from(args_vec.iter()) {
             Ok(args) => args.execute(),
             Err(e) => {
-                let first_arg_is_subcommand = if let Some(first_arg) = args().nth(1) {
+                let first_arg_is_subcommand = if let Some(first_arg) = args_vec.get(1) {
                     let mut ret = false;
                     let cmd = WasmerCmd::command();
 
@@ -265,16 +313,14 @@ impl WasmerCmd {
                         | clap::error::ErrorKind::UnknownArgument
                 ) && !first_arg_is_subcommand;
 
-                if might_be_wasmer_run {
-                    if let Ok(run) = Run::try_parse() {
-                        // Try to parse the command using the `wasmer some/package`
-                        // shorthand. Note that this has discoverability issues
-                        // because it's not shown as part of the main argument
-                        // parser's help, but that's fine.
-                        let output = crate::logging::Output::default();
-                        output.initialize_logging();
-                        run.execute(output);
-                    }
+                if might_be_wasmer_run && let Ok(run) = Run::try_parse_from(args_vec.iter()) {
+                    // Try to parse the command using the `wasmer some/package`
+                    // shorthand. Note that this has discoverability issues
+                    // because it's not shown as part of the main argument
+                    // parser's help, but that's fine.
+                    let output = crate::logging::Output::default();
+                    output.initialize_logging();
+                    run.execute(output);
                 }
 
                 e.exit();
@@ -287,7 +333,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 +341,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),
@@ -307,40 +353,39 @@ enum Cmd {
     #[cfg(feature = "compiler")]
     Compile(Compile),
 
-    /// Compile a WebAssembly binary into a native executable
-    ///
-    /// To use, you need to set the `WASMER_DIR` environment variable
-    /// to the location of your Wasmer installation. This will probably be `~/.wasmer`. It
-    /// should include a `lib`, `include` and `bin` subdirectories. To create an executable
-    /// you will need `libwasmer`, so by setting `WASMER_DIR` the CLI knows where to look for
-    /// header files and libraries.
-    ///
-    /// Example usage:
-    ///
-    /// ```text
-    /// $ # in two lines:
-    /// $ export WASMER_DIR=/home/user/.wasmer/
-    /// $ wasmer create-exe qjs.wasm -o qjs.exe # or in one line:
-    /// $ WASMER_DIR=/home/user/.wasmer/ wasmer create-exe qjs.wasm -o qjs.exe
-    /// $ file qjs.exe
-    /// qjs.exe: ELF 64-bit LSB pie executable, x86-64 ...
-    /// ```
-    ///
-    /// ## Cross-compilation
-    ///
-    /// Accepted target triple values must follow the
-    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
-    ///
-    /// The recommended targets we try to support are:
-    ///
-    /// - "x86_64-linux-gnu"
-    /// - "aarch64-linux-gnu"
-    /// - "x86_64-apple-darwin"
-    /// - "arm64-apple-darwin"
-    #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
-    #[clap(name = "create-exe", verbatim_doc_comment)]
-    CreateExe(CreateExe),
-
+    // Compile a WebAssembly binary into a native executable
+    //
+    // To use, you need to set the `WASMER_DIR` environment variable
+    // to the location of your Wasmer installation. This will probably be `~/.wasmer`. It
+    // should include a `lib`, `include` and `bin` subdirectories. To create an executable
+    // you will need `libwasmer`, so by setting `WASMER_DIR` the CLI knows where to look for
+    // header files and libraries.
+    //
+    // Example usage:
+    //
+    // ```text
+    // $ # in two lines:
+    // $ export WASMER_DIR=/home/user/.wasmer/
+    // $ wasmer create-exe qjs.wasm -o qjs.exe # or in one line:
+    // $ WASMER_DIR=/home/user/.wasmer/ wasmer create-exe qjs.wasm -o qjs.exe
+    // $ file qjs.exe
+    // qjs.exe: ELF 64-bit LSB pie executable, x86-64 ...
+    // ```
+    //
+    // ## Cross-compilation
+    //
+    // Accepted target triple values must follow the
+    // ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    //
+    // The recommended targets we try to support are:
+    //
+    // - "x86_64-linux-gnu"
+    // - "aarch64-linux-gnu"
+    // - "x86_64-apple-darwin"
+    // - "arm64-apple-darwin"
+    // #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+    // #[clap(name = "create-exe", verbatim_doc_comment)]
+    // CreateExe(CreateExe),
     /// Compile a WebAssembly binary into an object file
     ///
     /// To use, you need to set the `WASMER_DIR` environment variable to the location of your
@@ -370,11 +415,13 @@ enum Cmd {
     /// - "aarch64-linux-gnu"
     /// - "x86_64-apple-darwin"
     /// - "arm64-apple-darwin"
-    #[cfg(feature = "static-artifact-create")]
-    #[structopt(name = "create-obj", verbatim_doc_comment)]
-    CreateObj(CreateObj),
+    // #[cfg(feature = "static-artifact-create")]
+    // #[structopt(name = "create-obj", verbatim_doc_comment)]
+    // CreateObj(CreateObj),
 
+    ///
     /// Generate the C static_defs.h header file for the input .wasm module
+    ///
     #[cfg(feature = "static-artifact-create")]
     GenCHeader(GenCHeader),
 
@@ -405,7 +452,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")]
@@ -474,25 +521,64 @@ fn print_version(verbose: bool) -> Result<(), anyhow::Error> {
     println!(
         "wasmer {} ({} {})",
         env!("CARGO_PKG_VERSION"),
-        env!("WASMER_BUILD_GIT_HASH_SHORT"),
+        git_version!(
+            args = ["--abbrev=8", "--always", "--dirty=-modified", "--exclude=*"],
+            fallback = ""
+        ),
         env!("WASMER_BUILD_DATE")
     );
     println!("binary: {}", env!("CARGO_PKG_NAME"));
-    println!("commit-hash: {}", env!("WASMER_BUILD_GIT_HASH"));
+    println!(
+        "commit-hash: {}",
+        git_version!(
+            args = [
+                "--abbrev=40",
+                "--always",
+                "--dirty=-modified",
+                "--exclude=*"
+            ],
+            fallback = "",
+        ),
+    );
     println!("commit-date: {}", env!("WASMER_BUILD_DATE"));
     println!("host: {}", target_lexicon::HOST);
 
-    let mut compilers = Vec::<&'static str>::new();
+    let cpu_features = {
+        let feats = wasmer_types::target::CpuFeature::for_host();
+        let all = wasmer_types::target::CpuFeature::all();
+        all.iter()
+            .map(|f| {
+                let available = feats.contains(f);
+                format!("{}={}", f, if available { "true" } else { "false" })
+            })
+            .collect::<Vec<_>>()
+            .join(",")
+    };
+    println!("cpu: {cpu_features}");
+
+    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");
+    }
+
+    if cfg!(feature = "wamr") {
+        runtimes.push("wamr");
+    }
+
+    if cfg!(feature = "wasmi") {
+        runtimes.push("wasmi");
+    }
+
+    if cfg!(feature = "v8") {
+        runtimes.push("v8");
     }
-    println!("compiler: {}", compilers.join(","));
 
+    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..c0f14e6fe2 100644
--- a/lib/cli/src/commands/package/build.rs
+++ b/lib/cli/src/commands/package/build.rs
@@ -1,11 +1,11 @@
 use std::path::PathBuf;
 
 use anyhow::Context;
-use dialoguer::console::{style, Emoji};
+use dialoguer::console::{Emoji, style};
 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..377b5c4fe2 100644
--- a/lib/cli/src/commands/package/common/mod.rs
+++ b/lib/cli/src/commands/package/common/mod.rs
@@ -7,13 +7,10 @@ use colored::Colorize;
 use dialoguer::Confirm;
 use indicatif::{ProgressBar, ProgressStyle};
 use reqwest::Body;
-use std::{
-    collections::BTreeMap,
-    path::{Path, PathBuf},
-};
-use wasmer_api::WasmerClient;
+use std::path::{Path, PathBuf};
+use wasmer_backend_api::{WasmerClient, query::UploadMethod};
 use wasmer_config::package::{Manifest, NamedPackageIdent, PackageHash};
-use webc::wasmer_package::Package;
+use wasmer_package::package::Package;
 
 pub mod macros;
 pub mod wait;
@@ -44,18 +41,20 @@ 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),
             None,
             None,
+            Some(UploadMethod::R2),
         );
 
         match q.await? {
@@ -68,45 +67,20 @@ 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 res = client
-        .post(&session_uri)
-        .header(reqwest::header::CONTENT_LENGTH, "0")
-        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
-        .header("x-goog-resumable", "start");
+    let client = {
+        let builder = reqwest::Client::builder()
+            .default_headers(reqwest::header::HeaderMap::default())
+            .timeout(timeout.into());
 
-    let result = res.send().await?;
+        let builder = if let Some(proxy) = proxy {
+            builder.proxy(proxy)
+        } else {
+            builder
+        };
 
-    if result.status() != reqwest::StatusCode::from_u16(201).unwrap() {
-        return Err(anyhow::anyhow!(
-            "Uploading package failed: got HTTP {:?} when uploading",
-            result.status()
-        ));
-    }
+        builder.build().unwrap()
+    };
 
-    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")
-        .ok_or_else(|| {
-            anyhow::anyhow!("The upload server did not provide the upload URL correctly")
-        })?
-        .clone();
-
-    tracing::info!("session uri is: {session_uri}");
     /* XXX: If the package is large this line may result in
      * a surge in memory use.
      *
@@ -153,13 +127,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)
 }
@@ -210,7 +184,9 @@ pub(super) async fn login_user(
             }
         } else {
             let bin_name = self::macros::bin_name!();
-            eprintln!("You are not logged in. Use the `--token` flag or log in (use `{bin_name} login`) to {msg}.");
+            eprintln!(
+                "You are not logged in. Use the `--token` flag or log in (use `{bin_name} login`) to {msg}."
+            );
             anyhow::bail!("Stopping execution as the user is not logged in.")
         }
     }
@@ -234,3 +210,47 @@ pub(super) fn make_package_url(client: &WasmerClient, pkg: &NamedPackageIdent) -
         pkg.version_or_default().to_string().replace('=', "")
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Context;
+    use humantime::Duration as HumanDuration;
+    use indicatif::ProgressBar;
+    use sha2::{Digest, Sha256};
+    use url::Url;
+
+    #[tokio::test]
+    #[ignore = "Requires WASMER_REGISTRY_URL/WASMER_TOKEN"]
+    async fn test_upload_package_r2() -> anyhow::Result<()> {
+        let registry = std::env::var("WASMER_REGISTRY_URL")
+            .context("set WASMER_REGISTRY_URL to point at the registry GraphQL endpoint")?;
+        let token = std::env::var("WASMER_TOKEN")
+            .context("set WASMER_TOKEN for the registry under test")?;
+        let client = WasmerClient::new(Url::parse(&registry)?, "wasmer-cli-upload-test")?
+            .with_auth_token(token);
+        let pkg_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../tests/old-tar-gz/cowsay-0.3.0.tar.gz");
+        let package = Package::from_tarball_file(&pkg_path)?;
+        let bytes = package.serialize()?;
+        let hash_bytes: [u8; 32] = Sha256::digest(&bytes).into();
+        let hash = PackageHash::from_sha256_bytes(hash_bytes);
+        let pb = ProgressBar::hidden();
+
+        // Upload should succeed
+        let upload_url = upload(
+            &client,
+            &hash,
+            HumanDuration::from(std::time::Duration::from_secs(300)),
+            &package,
+            pb,
+            None,
+        )
+        .await?;
+        assert!(
+            upload_url.starts_with("http"),
+            "upload returned non-url: {upload_url}"
+        );
+        Ok(())
+    }
+}
diff --git a/lib/cli/src/commands/package/common/wait.rs b/lib/cli/src/commands/package/common/wait.rs
index 8fcba61e20..8704ae41cb 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::{WasmerClient, types::PackageVersionState};
 
 /// 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..e6adb9f51f 100644
--- a/lib/cli/src/commands/package/download.rs
+++ b/lib/cli/src/commands/package/download.rs
@@ -1,15 +1,23 @@
 use std::{env::current_dir, path::PathBuf};
 
-use anyhow::{bail, Context};
-use dialoguer::console::{style, Emoji};
+use anyhow::{Context, bail};
+use dialoguer::console::{Emoji, style};
 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,21 +181,21 @@ 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)
             }
             PackageSource::Path(p) => bail!("cannot download a package from a local path: '{p}'"),
-            PackageSource::Url(url) => bail!("cannot download a package from a URL: '{}'", url),
+            PackageSource::Url(url) => bail!("cannot download a package from a URL: '{url}'"),
         };
 
         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
@@ -180,15 +204,14 @@ impl PackageDownload {
 
         let b = client
             .get(download_url)
-            .header(http::header::ACCEPT, "application/webc");
+            .header(http::header::ACCEPT, "application/webc")
+            // NOTE: reqwest handles gzip/zstd decoding the response body
+            // automatically when the relevant features are enabled.
+            .header(http::header::ACCEPT_ENCODING, "zstd;q=1.0, gzip;q=0.8");
 
         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;
@@ -207,17 +230,13 @@ impl PackageDownload {
             .unwrap_or_default();
 
         if webc_total_size == 0 {
-            bail!("Package is empty");
+            // This can happen with Transfer-Encoding: Chunked!
+        } else {
+            // Set the length of the progress bar
+            pb.set_length(webc_total_size);
         }
 
-        // 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 +250,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 +262,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 +287,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 +337,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..bafeee76e2 100644
--- a/lib/cli/src/commands/package/publish.rs
+++ b/lib/cli/src/commands/package/publish.rs
@@ -1,18 +1,18 @@
 use crate::{
     commands::{
+        AsyncCliCommand,
         package::{
             common::{wait::*, *},
             push::PackagePush,
             tag::PackageTag,
         },
-        AsyncCliCommand,
     },
     config::WasmerEnv,
 };
 use colored::Colorize;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 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..831e60cb56 100644
--- a/lib/cli/src/commands/package/push.rs
+++ b/lib/cli/src/commands/package/push.rs
@@ -5,11 +5,11 @@ use crate::{
 };
 use anyhow::Context;
 use colored::Colorize;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 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.
 ///
@@ -65,12 +65,11 @@ impl PackagePush {
             return Ok(owner.clone());
         }
 
-        if let Some(pkg) = &manifest.package {
-            if let Some(ns) = &pkg.name {
-                if let Some(first) = ns.split('/').next() {
-                    return Ok(first.to_string());
-                }
-            }
+        if let Some(pkg) = &manifest.package
+            && let Some(ns) = &pkg.name
+            && let Some(first) = ns.split('/').next()
+        {
+            return Ok(first.to_string());
         }
 
         if self.non_interactive {
@@ -78,7 +77,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,
@@ -93,12 +92,11 @@ impl PackagePush {
             return Ok(Some(name.clone()));
         }
 
-        if let Some(pkg) = &manifest.package {
-            if let Some(ns) = &pkg.name {
-                if let Some(name) = ns.split('/').nth(1) {
-                    return Ok(Some(name.to_string()));
-                }
-            }
+        if let Some(pkg) = &manifest.package
+            && let Some(ns) = &pkg.name
+            && let Some(name) = ns.split('/').nth(1)
+        {
+            return Ok(Some(name.to_string()));
         }
 
         Ok(None)
@@ -112,7 +110,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 +126,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,
@@ -145,7 +151,9 @@ impl PackagePush {
                 if r.success {
                     r.package_webc.unwrap().id
                 } else {
-                    anyhow::bail!("An unidentified error occurred while publishing the package. (response had success: false)")
+                    anyhow::bail!(
+                        "An unidentified error occurred while publishing the package. (response had success: false)"
+                    )
                 }
             }
             None => anyhow::bail!("An unidentified error occurred while publishing the package."), // <- This is extremely bad..
@@ -176,7 +184,9 @@ impl PackagePush {
         let name = self.get_name(manifest).await?;
 
         let private = self.get_privacy(manifest);
-        tracing::info!("If published, package privacy is {private}, namespace is {namespace} and name is {name:?}");
+        tracing::info!(
+            "If published, package privacy is {private}, namespace is {namespace} and name is {name:?}"
+        );
 
         let pb = make_spinner!(
             self.quiet,
diff --git a/lib/cli/src/commands/package/tag.rs b/lib/cli/src/commands/package/tag.rs
index d936134956..fb2c44d436 100644
--- a/lib/cli/src/commands/package/tag.rs
+++ b/lib/cli/src/commands/package/tag.rs
@@ -1,19 +1,19 @@
 use crate::{
     commands::{
-        package::common::{macros::*, wait::wait_package, *},
         AsyncCliCommand,
+        package::common::{macros::*, wait::wait_package, *},
     },
     config::WasmerEnv,
 };
 use anyhow::Context;
 use colored::Colorize;
-use dialoguer::{theme::ColorfulTheme, Confirm};
-use is_terminal::IsTerminal;
+use dialoguer::{Confirm, theme::ColorfulTheme};
+use std::io::IsTerminal as _;
 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,12 +261,16 @@ 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!");
                 if !self.quiet {
-                    eprintln!("\n\nThe package with the required hash does not exist in the selected registry.");
+                    eprintln!(
+                        "\n\nThe package with the required hash does not exist in the selected registry."
+                    );
                     let bin_name = bin_name!();
                     let cli = std::env::args()
                         .filter(|s| !s.starts_with('-'))
@@ -312,12 +328,11 @@ impl PackageTag {
             return Ok(Some(name.clone()));
         }
 
-        if let Some(pkg) = &manifest.and_then(|m| m.package.as_ref()) {
-            if let Some(ns) = &pkg.name {
-                if let Some(name) = ns.split('/').nth(1) {
-                    return Ok(Some(name.to_string()));
-                }
-            }
+        if let Some(pkg) = &manifest.and_then(|m| m.package.as_ref())
+            && let Some(ns) = &pkg.name
+            && let Some(name) = ns.split('/').nth(1)
+        {
+            return Ok(Some(name.to_string()));
         }
 
         if allow_unnamed {
@@ -353,12 +368,11 @@ impl PackageTag {
             return Ok(namespace.clone());
         }
 
-        if let Some(pkg) = manifest.and_then(|m| m.package.clone()) {
-            if let Some(name) = &pkg.name {
-                if let Some(ns) = name.split('/').next() {
-                    return Ok(ns.to_string());
-                }
-            }
+        if let Some(pkg) = manifest.and_then(|m| m.package.clone())
+            && let Some(name) = &pkg.name
+            && let Some(ns) = name.split('/').next()
+        {
+            return Ok(ns.to_string());
         }
 
         if self.non_interactive {
@@ -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(),
@@ -452,7 +466,10 @@ impl PackageTag {
                     let mut new_version = registry_version.clone();
                     new_version.patch += 1;
                     if must_bump {
-                        eprintln!("{}: Registry already has version {user_version} of {full_pkg_name}, but with different contents.", "Warn".bold().yellow());
+                        eprintln!(
+                            "{}: Registry already has version {user_version} of {full_pkg_name}, but with different contents.",
+                            "Warn".bold().yellow()
+                        );
                         eprintln!(
                             "{}: Not bumping the version will make this action fail.",
                             "Warn".bold().yellow()
@@ -590,7 +607,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..25d58b429a 100644
--- a/lib/cli/src/commands/package/unpack.rs
+++ b/lib/cli/src/commands/package/unpack.rs
@@ -1,31 +1,58 @@
 use std::path::PathBuf;
 
 use anyhow::Context;
-use dialoguer::console::{style, Emoji};
+use dialoguer::console::{Emoji, style};
 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..43e3c36bc9 100644
--- a/lib/cli/src/commands/run/capabilities/mod.rs
+++ b/lib/cli/src/commands/run/capabilities/mod.rs
@@ -1,12 +1,14 @@
-use super::PackageSource;
+use crate::config::WasmerEnv;
+
+use super::CliPackageSource;
 use anyhow::anyhow;
 use sha2::{Digest, Sha256};
 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.
@@ -23,7 +25,7 @@ pub(crate) struct PkgCapabilityCache {
 
 pub(crate) fn get_capability_cache_path(
     env: &WasmerEnv,
-    input: &PackageSource,
+    input: &CliPackageSource,
 ) -> anyhow::Result<PathBuf> {
     let registry_name = env
         .registry_public_url()?
@@ -34,7 +36,7 @@ pub(crate) fn get_capability_cache_path(
     // We don't have the bytes of the module yet, but we still want to have the
     // package-capabilities cache be as close to an actual identifier as possible.
     let package_cache_path = match &input {
-        PackageSource::File(f) => {
+        CliPackageSource::File(f) => {
             let full_path = f.canonicalize()?.to_path_buf();
             let metadata = full_path
                 .parent()
@@ -59,7 +61,7 @@ pub(crate) fn get_capability_cache_path(
 
             format!("path_{}.json", hex::encode(hash.finalize()))
         }
-        PackageSource::Dir(f) => {
+        CliPackageSource::Dir(f) => {
             let full_path = f.canonicalize()?.to_path_buf();
             let metadata = full_path.metadata()?.modified()?;
 
@@ -80,7 +82,7 @@ pub(crate) fn get_capability_cache_path(
 
             format!("path_{}.json", hex::encode(hash.finalize()))
         }
-        PackageSource::Package(p) => match p {
+        CliPackageSource::Package(p) => match p {
             PackageSpecifier::Ident(id) => match id {
                 wasmer_config::package::PackageIdent::Named(n) => format!(
                     "ident_{}_{}",
@@ -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/capabilities/net.rs b/lib/cli/src/commands/run/capabilities/net.rs
index 7f12fd7368..d6610260ad 100644
--- a/lib/cli/src/commands/run/capabilities/net.rs
+++ b/lib/cli/src/commands/run/capabilities/net.rs
@@ -7,7 +7,7 @@ use std::{
     time::Duration,
 };
 
-use super::{super::PackageSource, PkgCapabilityCache};
+use super::{super::CliPackageSource, PkgCapabilityCache};
 use anyhow::Context;
 use colored::Colorize;
 use dialoguer::theme::ColorfulTheme;
diff --git a/lib/cli/src/commands/run/mod.rs b/lib/cli/src/commands/run/mod.rs
index eefc629f72..62aa508009 100644
--- a/lib/cli/src/commands/run/mod.rs
+++ b/lib/cli/src/commands/run/mod.rs
@@ -1,10 +1,13 @@
 #![allow(missing_docs, unused)]
 
 mod capabilities;
+mod package_source;
+mod runtime;
+mod target;
 mod wasi;
 
 use std::{
-    collections::{hash_map::DefaultHasher, BTreeMap},
+    collections::{BTreeMap, hash_map::DefaultHasher},
     fmt::{Binary, Display},
     fs::File,
     hash::{BuildHasherDefault, Hash, Hasher},
@@ -16,48 +19,62 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-use anyhow::{anyhow, bail, Context, Error};
+use anyhow::{Context, Error, anyhow, bail};
 use clap::{Parser, ValueEnum};
+use colored::Colorize;
+use futures::future::BoxFuture;
 use indicatif::{MultiProgress, ProgressBar};
 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, RuntimeError, Store,
+    Type, TypedFunction, Value, wat2wasm,
 };
 
+use wasmer_types::{Features, target::Target};
+
 #[cfg(feature = "compiler")]
 use wasmer_compiler::ArtifactBuild;
-use wasmer_config::package::PackageSource as PackageSpecifier;
-use wasmer_registry::{wasmer_env::WasmerEnv, Package};
+use wasmer_config::package::PackageSource;
+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,
+    Runtime, SpawnError, WasiError,
+    bin_factory::{BinaryPackage, BinaryPackageCommand},
     journal::CompactingLogFileJournal,
     runners::{
+        MappedCommand, MappedDirectory, Runner,
         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,
 };
-use webc::{metadata::Manifest, Container};
+use webc::Container;
+use webc::metadata::Manifest;
 
 use crate::{
-    commands::run::wasi::Wasi, common::HashAlgorithm, error::PrettyError, logging::Output,
-    store::StoreOptions,
+    backend::RuntimeOptions,
+    commands::run::{target::TargetOnDisk, wasi::Wasi},
+    config::WasmerEnv,
+    error::PrettyError,
+    logging::Output,
+};
+
+use self::{
+    package_source::CliPackageSource, runtime::MonitoringRuntime, target::ExecutableTarget,
 };
 
 const TICK: Duration = Duration::from_millis(250);
@@ -68,7 +85,7 @@ pub struct Run {
     #[clap(flatten)]
     env: WasmerEnv,
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
     #[clap(flatten)]
     wasi: crate::commands::run::Wasi,
     #[clap(flatten)]
@@ -76,20 +93,20 @@ 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>,
     /// The file, URL, or package to run.
-    #[clap(value_parser = PackageSource::infer)]
-    input: PackageSource,
+    #[clap(value_parser = CliPackageSource::infer)]
+    input: CliPackageSource,
     /// Command-line arguments passed to the package
     args: Vec<String>,
-    /// Hashing algorithm to be used for module hash
-    #[clap(long, value_enum)]
-    hash_algorithm: Option<HashAlgorithm>,
 }
 
 impl Run {
@@ -100,6 +117,8 @@ impl Run {
 
     #[tracing::instrument(level = "debug", name = "wasmer_run", skip_all)]
     fn execute_inner(mut self, output: Output) -> Result<(), Error> {
+        self.print_option_warnings();
+
         let pb = ProgressBar::new_spinner();
         pb.set_draw_target(output.draw_target());
         pb.enable_steady_tick(TICK);
@@ -111,11 +130,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 +142,83 @@ impl Run {
         };
 
         let _guard = handle.enter();
-        let (store, _) = self.store.get_store()?;
 
-        #[cfg(feature = "sys")]
-        let engine = {
-            let mut engine = store.engine().clone();
-            let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
-            engine.set_hash_algorithm(Some(hash_algorithm));
+        // 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 CliPackageSource::File(path) = &self.input {
+            tracing::info!("Input file path: {}", path.display());
+
+            // Try to read and detect any file that exists, regardless of extension
+            let target = TargetOnDisk::from_file(path);
+            if let Ok(target) = target {
+                match target {
+                    TargetOnDisk::WebAssemblyBinary => {
+                        if let Ok(data) = std::fs::read(path) {
+                            wasm_bytes = Some(data);
+                        } else {
+                            tracing::info!("Failed to read file: {}", path.display());
+                        }
+                    }
+                    TargetOnDisk::Wat => match std::fs::read(path) {
+                        Ok(data) => match wat2wasm(&data) {
+                            Ok(wasm) => {
+                                wasm_bytes = Some(wasm.to_vec());
+                            }
+                            Err(e) => {
+                                tracing::info!(
+                                    "Failed to convert WAT to Wasm for {}: {e}",
+                                    path.display()
+                                );
+                            }
+                        },
+                        Err(e) => {
+                            tracing::info!("Failed to read WAT file {}: {e}", path.display());
+                        }
+                    },
+                    _ => {}
+                }
+            } else {
+                tracing::info!(
+                    "Failed to read file for feature detection: {}",
+                    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");
 
-            engine
+                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 CliPackageSource::Package(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())?
+                }
+            }
         };
-        #[cfg(not(feature = "sys"))]
-        let engine = store.engine().clone();
+
+        let engine_kind = engine.deterministic_id();
+        tracing::info!("Executing on backend {engine_kind:?}");
+
+        #[cfg(feature = "sys")]
+        if engine.is_sys() && self.stack_size.is_some() {
+            wasmer_vm::set_stack_size(self.stack_size.unwrap());
+        }
+
+        let engine = engine.clone();
 
         let runtime = self.wasi.prepare_runtime(
             engine,
@@ -151,7 +230,11 @@ impl Run {
 
         // This is a slow operation, so let's temporarily wrap the runtime with
         // something that displays progress
-        let monitoring_runtime = Arc::new(MonitoringRuntime::new(runtime, pb.clone()));
+        let monitoring_runtime = Arc::new(MonitoringRuntime::new(
+            runtime,
+            pb.clone(),
+            output.is_quiet_or_no_tty(),
+        ));
         let runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime.runtime.clone();
         let monitoring_runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime;
 
@@ -159,7 +242,7 @@ impl Run {
 
         if let ExecutableTarget::Package(ref pkg) = target {
             self.wasi
-                .mapped_dirs
+                .all_volumes()
                 .extend(pkg.additional_host_mapped_directories.clone());
         }
 
@@ -174,16 +257,77 @@ 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()
+                        && 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 capability_cache_path =
+                                    capabilities::get_capability_cache_path(
+                                        &self.env,
+                                        &self.input,
+                                    )?;
+                                let new_runtime = self.wasi.prepare_runtime(
+                                    new_engine,
+                                    &self.env,
+                                    &capability_cache_path,
+                                    tokio::runtime::Builder::new_multi_thread()
+                                        .enable_all()
+                                        .build()?,
+                                    preferred_webc_version,
+                                )?;
+
+                                let new_runtime = Arc::new(MonitoringRuntime::new(
+                                    new_runtime,
+                                    pb.clone(),
+                                    output.is_quiet_or_no_tty(),
+                                ));
+                                return self.execute_webc(&pkg, new_runtime);
+                            }
+                        }
+                    }
+                    self.execute_webc(&pkg, monitoring_runtime)
+                }
             }
         };
 
         // restore the TTY state as the execution may have changed it
-        if let Some(state) = tty {
-            if let Some(tty) = runtime.tty() {
-                tty.tty_set(state);
-            }
+        if let Some(state) = tty
+            && let Some(tty) = runtime.tty()
+        {
+            tty.tty_set(state);
         }
 
         if let Err(e) = &result {
@@ -197,17 +341,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 +360,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 +376,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 \"{}\"",
@@ -253,7 +392,8 @@ impl Run {
         let mut dependencies = Vec::new();
 
         for name in &self.wasi.uses {
-            let specifier = PackageSpecifier::from_str(name)
+            let specifier = name
+                .parse::<PackageSource>()
                 .with_context(|| format!("Unable to parse \"{name}\" as a package specifier"))?;
             let pkg = {
                 let specifier = specifier.clone();
@@ -278,8 +418,9 @@ impl Run {
         uses: Vec<BinaryPackage>,
         runtime: Arc<dyn Runtime + Send + Sync>,
     ) -> Result<(), Error> {
-        let mut runner = self.build_wasi_runner(&runtime)?;
-        runner.run_command(command_name, pkg, runtime)
+        // Assume webcs are always WASIX
+        let mut runner = self.build_wasi_runner(&runtime, true)?;
+        Runner::run_command(&mut runner, command_name, pkg, runtime)
     }
 
     fn run_wcgi(
@@ -303,7 +444,7 @@ impl Run {
             .args(self.args.clone())
             .addr(self.wcgi.addr)
             .envs(self.wasi.env_vars.clone())
-            .map_directories(self.wasi.mapped_dirs.clone())
+            .map_directories(self.wasi.all_volumes())
             .callbacks(Callbacks::new(self.wcgi.addr))
             .inject_packages(uses);
         *config.capabilities() = self.wasi.capabilities();
@@ -316,19 +457,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);
             }
         }
 
@@ -354,65 +502,62 @@ impl Run {
         pkg: &BinaryPackage,
         runtime: Arc<dyn Runtime + Send + Sync>,
     ) -> Result<(), Error> {
-        let mut inner = self.build_wasi_runner(&runtime)?;
+        let mut inner = self.build_wasi_runner(&runtime, true)?;
         let mut runner = wasmer_wasix::runners::dproxy::DProxyRunner::new(inner, pkg);
         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)?;
-
-        println!(
-            "{}",
-            return_values
-                .iter()
-                .map(|val| val.to_string())
-                .collect::<Vec<String>>()
-                .join(" ")
-        );
-
-        Ok(())
+        let result = invoke_function(&instance, &mut store, entry_function, &self.args)?;
+
+        match result {
+            Ok(return_values) => {
+                println!(
+                    "{}",
+                    return_values
+                        .iter()
+                        .map(|val| val.to_string())
+                        .collect::<Vec<String>>()
+                        .join(" ")
+                );
+                Ok(())
+            }
+            Err(err) => {
+                bail!("{}", err.display(&mut store));
+            }
+        }
     }
 
     fn build_wasi_runner(
         &self,
         runtime: &Arc<dyn Runtime + Send + Sync>,
+        is_wasix: bool,
     ) -> Result<WasiRunner, anyhow::Error> {
         let packages = self.load_injected_packages(runtime)?;
 
         let mut runner = WasiRunner::new();
 
-        let (is_home_mapped, is_tmp_mapped, mapped_diretories) =
-            self.wasi.build_mapped_directories()?;
+        let (is_home_mapped, mapped_diretories) = self.wasi.build_mapped_directories(is_wasix)?;
 
         runner
             .with_args(&self.args)
@@ -421,29 +566,47 @@ impl Run {
             .with_mapped_host_commands(self.wasi.build_mapped_commands()?)
             .with_mapped_directories(mapped_diretories)
             .with_home_mapped(is_home_mapped)
-            .with_tmp_mapped(is_tmp_mapped)
             .with_forward_host_env(self.wasi.forward_host_env)
             .with_capabilities(self.wasi.capabilities());
 
+        if let Some(cwd) = self.wasi.cwd.as_ref() {
+            if !cwd.starts_with("/") {
+                bail!("The argument to --cwd must be an absolute path");
+            }
+            runner.with_current_dir(cwd.clone());
+        }
+
+        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,77 +616,52 @@ 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)?;
+        let runner = self.build_wasi_runner(&runtime, wasmer_wasix::is_wasix_module(&module))?;
         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")]
-        if let Some(coredump) = &self.coredump_on_trap {
-            if let Err(e) = generate_coredump(e, self.input.to_string(), coredump) {
-                tracing::warn!(
-                    error = &*e as &dyn std::error::Error,
-                    coredump_path=%coredump.display(),
-                    "Unable to generate a coredump",
-                );
-            }
+        if let Some(coredump) = &self.coredump_on_trap
+            && let Err(e) = generate_coredump(e, self.input.to_string(), coredump)
+        {
+            tracing::warn!(
+                error = &*e as &dyn std::error::Error,
+                coredump_path=%coredump.display(),
+                "Unable to generate a coredump",
+            );
         }
     }
 
-    /// Create Run instance for arguments/env, assuming we're being run from a
-    /// CFP binfmt interpreter.
-    pub fn from_binfmt_args() -> Self {
-        Run::from_binfmt_args_fallible().unwrap_or_else(|e| {
-            crate::error::PrettyError::report::<()>(
-                Err(e).context("Failed to set up wasmer binfmt invocation"),
-            )
-        })
-    }
-
-    fn from_binfmt_args_fallible() -> Result<Self, Error> {
-        if !cfg!(linux) {
-            bail!("binfmt_misc is only available on linux.");
+    fn print_option_warnings(&self) {
+        if !self.wasi.mapped_dirs.is_empty() {
+            eprintln!(
+                "{}The `{}` option is deprecated and will be removed in the next major release. Please use `{}` instead.",
+                "warning: ".yellow(),
+                "--mapdir".yellow(),
+                "--volume".green()
+            );
+        }
+        if !self.wasi.pre_opened_directories.is_empty() {
+            eprintln!(
+                "{}The `{}` option is deprecated and will be removed in the next major release. Please use `{}` instead.",
+                "warning: ".yellow(),
+                "--dir".yellow(),
+                "--volume".green()
+            );
         }
-
-        let argv = std::env::args().collect::<Vec<_>>();
-        let (_interpreter, executable, original_executable, args) = match &argv[..] {
-            [a, b, c, rest @ ..] => (a, b, c, rest),
-            _ => {
-                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();
-        Ok(Run {
-            env: WasmerEnv::default(),
-            store,
-            wasi: Wasi::for_binfmt_interpreter()?,
-            wcgi: WcgiOptions::default(),
-            stack_size: None,
-            entrypoint: Some(original_executable.to_string()),
-            coredump_on_trap: None,
-            input: PackageSource::infer(executable)?,
-            args: args.to_vec(),
-            hash_algorithm: None,
-        })
     }
 }
 
@@ -532,16 +670,14 @@ fn invoke_function(
     store: &mut Store,
     func: &Function,
     args: &[String],
-) -> Result<Box<[Value]>, Error> {
+) -> anyhow::Result<Result<Box<[Value]>, RuntimeError>> {
     let func_ty = func.ty(store);
     let required_arguments = func_ty.params().len();
     let provided_arguments = args.len();
 
     anyhow::ensure!(
         required_arguments == provided_arguments,
-        "Function expected {} arguments, but received {}",
-        required_arguments,
-        provided_arguments,
+        "Function expected {required_arguments} arguments, but received {provided_arguments}"
     );
 
     let invoke_args = args
@@ -553,9 +689,7 @@ fn invoke_function(
         })
         .collect::<Result<Vec<_>, _>>()?;
 
-    let return_values = func.call(store, &invoke_args)?;
-
-    Ok(return_values)
+    Ok(func.call(store, &invoke_args))
 }
 
 fn parse_value(s: &str, ty: wasmer_types::Type) -> Result<Value, Error> {
@@ -570,221 +704,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 {
-    /// A file on disk (`*.wasm`, `*.webc`, etc.).
-    File(PathBuf),
-    /// A directory containing a `wasmer.toml` file
-    Dir(PathBuf),
-    /// A package to be downloaded (a URL, package name, etc.)
-    Package(PackageSpecifier),
-}
-
-impl PackageSource {
-    fn infer(s: &str) -> Result<PackageSource, Error> {
-        let path = Path::new(s);
-        if path.is_file() {
-            return Ok(PackageSource::File(path.to_path_buf()));
-        } else if path.is_dir() {
-            return Ok(PackageSource::Dir(path.to_path_buf()));
-        }
-
-        if let Ok(pkg) = PackageSpecifier::from_str(s) {
-            return Ok(PackageSource::Package(pkg));
-        }
-
-        Err(anyhow::anyhow!(
-            "Unable to resolve \"{s}\" as a URL, package name, or file on disk"
-        ))
-    }
-
-    /// Try to resolve the [`PackageSource`] to an executable artifact.
-    ///
-    /// This will try to automatically download and cache any resources from the
-    /// internet.
-    #[tracing::instrument(level = "debug", skip_all)]
-    fn resolve_target(
-        &self,
-        rt: &Arc<dyn Runtime + Send + Sync>,
-        pb: &ProgressBar,
-    ) -> Result<ExecutableTarget, Error> {
-        match self {
-            PackageSource::File(path) => ExecutableTarget::from_file(path, rt, pb),
-            PackageSource::Dir(d) => ExecutableTarget::from_dir(d, rt, pb),
-            PackageSource::Package(pkg) => {
-                pb.set_message("Loading from the registry");
-                let inner_pck = pkg.clone();
-                let inner_rt = rt.clone();
-                let pkg = rt.task_manager().spawn_and_block_on(async move {
-                    BinaryPackage::from_registry(&inner_pck, inner_rt.as_ref()).await
-                })??;
-                Ok(ExecutableTarget::Package(pkg))
-            }
-        }
-    }
-}
-
-impl Display for PackageSource {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            PackageSource::File(path) | PackageSource::Dir(path) => write!(f, "{}", path.display()),
-            PackageSource::Package(p) => write!(f, "{p}"),
-        }
-    }
-}
-
-/// We've been given the path for a file... What does it contain and how should
-/// that be run?
-#[derive(Debug, Clone)]
-enum TargetOnDisk {
-    WebAssemblyBinary,
-    Wat,
-    LocalWebc,
-    Artifact,
-}
-
-impl TargetOnDisk {
-    fn from_file(path: &Path) -> Result<TargetOnDisk, Error> {
-        // Normally the first couple hundred bytes is enough to figure
-        // out what type of file this is.
-        let mut buffer = [0_u8; 512];
-
-        let mut f = File::open(path)
-            .with_context(|| format!("Unable to open \"{}\" for reading", path.display(),))?;
-        let bytes_read = f.read(&mut buffer)?;
-
-        let leading_bytes = &buffer[..bytes_read];
-
-        if wasmer::is_wasm(leading_bytes) {
-            return Ok(TargetOnDisk::WebAssemblyBinary);
-        }
-
-        if webc::detect(leading_bytes).is_ok() {
-            return Ok(TargetOnDisk::LocalWebc);
-        }
-
-        #[cfg(feature = "compiler")]
-        if ArtifactBuild::is_deserializable(leading_bytes) {
-            return Ok(TargetOnDisk::Artifact);
-        }
-
-        // If we can't figure out the file type based on its content, fall back
-        // to checking the extension.
-
-        match path.extension().and_then(|s| s.to_str()) {
-            Some("wat") => Ok(TargetOnDisk::Wat),
-            Some("wasm") => Ok(TargetOnDisk::WebAssemblyBinary),
-            Some("webc") => Ok(TargetOnDisk::LocalWebc),
-            Some("wasmu") => Ok(TargetOnDisk::WebAssemblyBinary),
-            _ => bail!("Unable to determine how to execute \"{}\"", path.display()),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-enum ExecutableTarget {
-    WebAssembly {
-        module: Module,
-        module_hash: ModuleHash,
-        path: PathBuf,
-    },
-    Package(BinaryPackage),
-}
-
-impl ExecutableTarget {
-    /// Try to load a Wasmer package from a directory containing a `wasmer.toml`
-    /// file.
-    #[tracing::instrument(level = "debug", skip_all)]
-    fn from_dir(
-        dir: &Path,
-        runtime: &Arc<dyn Runtime + Send + Sync>,
-        pb: &ProgressBar,
-    ) -> Result<Self, Error> {
-        pb.set_message(format!("Loading \"{}\" into memory", dir.display()));
-        pb.set_message("Resolving dependencies");
-        let inner_runtime = runtime.clone();
-        let pkg = runtime.task_manager().spawn_and_block_on({
-            let path = dir.to_path_buf();
-
-            async move { BinaryPackage::from_dir(&path, inner_runtime.as_ref()).await }
-        })??;
-
-        Ok(ExecutableTarget::Package(pkg))
-    }
-
-    /// Try to load a file into something that can be used to run it.
-    #[tracing::instrument(level = "debug", skip_all)]
-    fn from_file(
-        path: &Path,
-        runtime: &Arc<dyn Runtime + Send + Sync>,
-        pb: &ProgressBar,
-    ) -> Result<Self, Error> {
-        pb.set_message(format!("Loading from \"{}\"", path.display()));
-
-        match TargetOnDisk::from_file(path)? {
-            TargetOnDisk::WebAssemblyBinary | TargetOnDisk::Wat => {
-                let wasm = std::fs::read(path)?;
-
-                pb.set_message("Compiling to WebAssembly");
-                let module = runtime
-                    .load_module_sync(&wasm)
-                    .with_context(|| format!("Unable to compile \"{}\"", path.display()))?;
-
-                Ok(ExecutableTarget::WebAssembly {
-                    module,
-                    module_hash: ModuleHash::xxhash(&wasm),
-                    path: path.to_path_buf(),
-                })
-            }
-            TargetOnDisk::Artifact => {
-                let engine = runtime.engine();
-                pb.set_message("Deserializing pre-compiled WebAssembly module");
-                let module = unsafe { Module::deserialize_from_file(&engine, path)? };
-
-                let module_hash = module.info().hash.ok_or_else(|| {
-                    anyhow::Error::msg("module hash is not present in the artifact")
-                })?;
-
-                Ok(ExecutableTarget::WebAssembly {
-                    module,
-                    module_hash,
-                    path: path.to_path_buf(),
-                })
-            }
-            TargetOnDisk::LocalWebc => {
-                let container = Container::from_disk(path)?;
-                pb.set_message("Resolving dependencies");
-
-                let inner_runtime = runtime.clone();
-                let pkg = runtime.task_manager().spawn_and_block_on(async move {
-                    BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
-                })??;
-                Ok(ExecutableTarget::Package(pkg))
-            }
-        }
-    }
-}
-
 #[cfg(feature = "coredump")]
 fn generate_coredump(err: &Error, source_name: String, coredump_path: &Path) -> Result<(), Error> {
     let err: &wasmer::RuntimeError = match err.downcast_ref() {
@@ -906,115 +825,3 @@ fn get_exit_code(
 
     None
 }
-
-#[derive(Debug)]
-struct MonitoringRuntime<R> {
-    runtime: Arc<R>,
-    progress: ProgressBar,
-}
-
-impl<R> MonitoringRuntime<R> {
-    fn new(runtime: R, progress: ProgressBar) -> Self {
-        MonitoringRuntime {
-            runtime: Arc::new(runtime),
-            progress,
-        }
-    }
-}
-
-impl<R: wasmer_wasix::Runtime + Send + Sync> wasmer_wasix::Runtime for MonitoringRuntime<R> {
-    fn networking(&self) -> &virtual_net::DynVirtualNetworking {
-        self.runtime.networking()
-    }
-
-    fn task_manager(&self) -> &Arc<dyn wasmer_wasix::VirtualTaskManager> {
-        self.runtime.task_manager()
-    }
-
-    fn package_loader(
-        &self,
-    ) -> Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync> {
-        let inner = self.runtime.package_loader();
-        Arc::new(MonitoringPackageLoader {
-            inner,
-            progress: self.progress.clone(),
-        })
-    }
-
-    fn module_cache(
-        &self,
-    ) -> Arc<dyn wasmer_wasix::runtime::module_cache::ModuleCache + Send + Sync> {
-        self.runtime.module_cache()
-    }
-
-    fn source(&self) -> Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync> {
-        let inner = self.runtime.source();
-        Arc::new(MonitoringSource {
-            inner,
-            progress: self.progress.clone(),
-        })
-    }
-
-    fn engine(&self) -> wasmer::Engine {
-        self.runtime.engine()
-    }
-
-    fn new_store(&self) -> wasmer::Store {
-        self.runtime.new_store()
-    }
-
-    fn http_client(&self) -> Option<&wasmer_wasix::http::DynHttpClient> {
-        self.runtime.http_client()
-    }
-
-    fn tty(&self) -> Option<&(dyn wasmer_wasix::os::TtyBridge + Send + Sync)> {
-        self.runtime.tty()
-    }
-}
-
-#[derive(Debug)]
-struct MonitoringSource {
-    inner: Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync>,
-    progress: ProgressBar,
-}
-
-#[async_trait::async_trait]
-impl wasmer_wasix::runtime::resolver::Source for MonitoringSource {
-    async fn query(
-        &self,
-        package: &PackageSpecifier,
-    ) -> Result<Vec<wasmer_wasix::runtime::resolver::PackageSummary>, QueryError> {
-        self.progress.set_message(format!("Looking up {package}"));
-        self.inner.query(package).await
-    }
-}
-
-#[derive(Debug)]
-struct MonitoringPackageLoader {
-    inner: Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync>,
-    progress: ProgressBar,
-}
-
-#[async_trait::async_trait]
-impl wasmer_wasix::runtime::package_loader::PackageLoader for MonitoringPackageLoader {
-    async fn load(
-        &self,
-        summary: &wasmer_wasix::runtime::resolver::PackageSummary,
-    ) -> Result<Container, Error> {
-        let pkg_id = summary.package_id();
-        self.progress.set_message(format!("Downloading {pkg_id}"));
-
-        self.inner.load(summary).await
-    }
-
-    async fn load_package_tree(
-        &self,
-        root: &Container,
-        resolution: &wasmer_wasix::runtime::resolver::Resolution,
-        root_is_local_dir: bool,
-    ) -> Result<BinaryPackage, Error> {
-        self.inner
-            .load_package_tree(root, resolution, root_is_local_dir)
-            .await
-    }
-}
diff --git a/lib/cli/src/commands/run/package_source.rs b/lib/cli/src/commands/run/package_source.rs
new file mode 100644
index 0000000000..92c5d76faa
--- /dev/null
+++ b/lib/cli/src/commands/run/package_source.rs
@@ -0,0 +1,79 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::Error;
+use indicatif::ProgressBar;
+use wasmer_config::package::PackageSource;
+use wasmer_wasix::{
+    Runtime, bin_factory::BinaryPackage, runtime::task_manager::VirtualTaskManagerExt as _,
+};
+
+use super::ExecutableTarget;
+
+/// CLI representation of a target to execute.
+#[derive(Debug, Clone, PartialEq)]
+pub enum CliPackageSource {
+    /// A file on disk (`*.wasm`, `*.webc`, etc.).
+    File(PathBuf),
+    /// A directory containing a `wasmer.toml` file
+    Dir(PathBuf),
+    /// A package to be downloaded (a URL, package name, etc.)
+    Package(PackageSource),
+}
+
+impl CliPackageSource {
+    pub fn infer(s: &str) -> Result<CliPackageSource, Error> {
+        let path = Path::new(s);
+        if path.is_file() {
+            return Ok(Self::File(path.to_path_buf()));
+        } else if path.is_dir() {
+            return Ok(Self::Dir(path.to_path_buf()));
+        }
+
+        if let Ok(pkg) = s.parse::<PackageSource>() {
+            return Ok(Self::Package(pkg));
+        }
+
+        Err(anyhow::anyhow!(
+            "Unable to resolve \"{s}\" as a URL, package name, or file on disk"
+        ))
+    }
+
+    /// Try to resolve the [`PackageSource`] to an executable artifact.
+    ///
+    /// This will try to automatically download and cache any resources from the
+    /// internet.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn resolve_target(
+        &self,
+        rt: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<ExecutableTarget, Error> {
+        match self {
+            Self::File(path) => ExecutableTarget::from_file(path, rt, pb),
+            Self::Dir(d) => ExecutableTarget::from_dir(d, rt, pb),
+            Self::Package(pkg) => {
+                pb.set_message("Loading from the registry");
+                let inner_pck = pkg.clone();
+                let inner_rt = rt.clone();
+                let pkg = rt.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_registry(&inner_pck, inner_rt.as_ref()).await
+                })??;
+                Ok(ExecutableTarget::Package(Box::new(pkg)))
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for CliPackageSource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::File(path) | Self::Dir(path) => {
+                write!(f, "{}", path.display())
+            }
+            Self::Package(p) => write!(f, "{p}"),
+        }
+    }
+}
diff --git a/lib/cli/src/commands/run/runtime.rs b/lib/cli/src/commands/run/runtime.rs
new file mode 100644
index 0000000000..bac68961ac
--- /dev/null
+++ b/lib/cli/src/commands/run/runtime.rs
@@ -0,0 +1,240 @@
+//! Provides CLI-specific Wasix components.
+
+use std::{sync::Arc, time::Duration};
+
+use anyhow::Error;
+use futures::future::BoxFuture;
+use indicatif::ProgressBar;
+use std::io::IsTerminal as _;
+use wasmer::{Engine, Module};
+use wasmer_config::package::PackageSource;
+use wasmer_types::ModuleHash;
+use wasmer_wasix::{
+    SpawnError,
+    bin_factory::{BinaryPackage, BinaryPackageCommand},
+    runtime::{
+        ModuleInput,
+        module_cache::{
+            HashedModuleData,
+            progress::{ModuleLoadProgress, ModuleLoadProgressReporter},
+        },
+        resolver::{PackageSummary, QueryError},
+    },
+};
+use webc::Container;
+
+/// Special wasix runtime implementation for the CLI.
+///
+/// Wraps an undelrying runtime and adds progress monitoring for package
+/// compilation.
+#[derive(Debug)]
+pub struct MonitoringRuntime<R> {
+    pub runtime: Arc<R>,
+    progress: ProgressBar,
+    quiet_mode: bool,
+}
+
+impl<R> MonitoringRuntime<R> {
+    pub fn new(runtime: R, progress: ProgressBar, quiet_mode: bool) -> Self {
+        MonitoringRuntime {
+            runtime: Arc::new(runtime),
+            progress,
+            quiet_mode,
+        }
+    }
+}
+
+impl<R: wasmer_wasix::Runtime + Send + Sync> wasmer_wasix::Runtime for MonitoringRuntime<R> {
+    fn networking(&self) -> &virtual_net::DynVirtualNetworking {
+        self.runtime.networking()
+    }
+
+    fn task_manager(&self) -> &Arc<dyn wasmer_wasix::VirtualTaskManager> {
+        self.runtime.task_manager()
+    }
+
+    fn package_loader(
+        &self,
+    ) -> Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync> {
+        let inner = self.runtime.package_loader();
+        Arc::new(MonitoringPackageLoader {
+            inner,
+            progress: self.progress.clone(),
+        })
+    }
+
+    fn module_cache(
+        &self,
+    ) -> Arc<dyn wasmer_wasix::runtime::module_cache::ModuleCache + Send + Sync> {
+        self.runtime.module_cache()
+    }
+
+    fn source(&self) -> Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync> {
+        let inner = self.runtime.source();
+        Arc::new(MonitoringSource {
+            inner,
+            progress: self.progress.clone(),
+        })
+    }
+
+    fn engine(&self) -> Engine {
+        self.runtime.engine()
+    }
+
+    fn new_store(&self) -> wasmer::Store {
+        self.runtime.new_store()
+    }
+
+    fn http_client(&self) -> Option<&wasmer_wasix::http::DynHttpClient> {
+        self.runtime.http_client()
+    }
+
+    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 resolve_module<'a>(
+        &'a self,
+        input: ModuleInput<'a>,
+        engine: Option<&Engine>,
+        on_progress: Option<ModuleLoadProgressReporter>,
+    ) -> BoxFuture<'a, Result<Module, SpawnError>> {
+        // If a progress reporter is already provided, or quiet mode is enabled,
+        // just delegate to the inner runtime.
+        if on_progress.is_some() || self.quiet_mode {
+            return self.runtime.resolve_module(input, engine, on_progress);
+        }
+
+        // Compile with progress monitoring through the progress bar.
+
+        use std::fmt::Write as _;
+
+        let short_hash = input.hash().short_hash();
+        let progress_msg = match &input {
+            ModuleInput::Bytes(_) | ModuleInput::Hashed(_) => {
+                format!("Compiling module ({short_hash})")
+            }
+            ModuleInput::Command(cmd) => format!("Compiling {}", cmd.name()),
+        };
+
+        let pb = self.progress.clone();
+
+        let on_progress = Some(ModuleLoadProgressReporter::new({
+            let base_msg = progress_msg.clone();
+            move |prog| {
+                let msg = match prog {
+                    ModuleLoadProgress::CompilingModule(c) => {
+                        let mut msg = base_msg.clone();
+                        if let (Some(step), Some(step_count)) =
+                            (c.phase_step(), c.phase_step_count())
+                        {
+                            pb.set_length(step_count);
+                            pb.set_position(step);
+                            // Note: writing to strings can not fail.
+                            write!(msg, " ({step}/{step_count})").unwrap();
+                        };
+                        pb.tick();
+
+                        msg
+                    }
+                    _ => base_msg.clone(),
+                };
+
+                pb.set_message(msg);
+                Ok(())
+            }
+        }));
+
+        let engine = engine.cloned();
+
+        let style = indicatif::ProgressStyle::default_bar()
+            .template("{spinner} {wide_bar:.cyan/blue} {msg}")
+            .expect("invalid progress bar template");
+        self.progress.set_style(style);
+
+        self.progress.reset();
+        if self.progress.is_hidden() {
+            self.progress
+                .set_draw_target(indicatif::ProgressDrawTarget::stderr());
+        }
+        self.progress.set_message(progress_msg);
+
+        let f = async move {
+            let res = self
+                .runtime
+                .resolve_module(input, engine.as_ref(), on_progress)
+                .await;
+
+            // Hide the progress bar and reset it to the default spinner style.
+            // Needed because future module downloads should not show a bar.
+            self.progress
+                .set_style(indicatif::ProgressStyle::default_spinner());
+            self.progress.reset();
+            self.progress.finish_and_clear();
+
+            res
+        };
+
+        Box::pin(f)
+    }
+}
+
+#[derive(Debug)]
+struct MonitoringSource {
+    inner: Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync>,
+    progress: ProgressBar,
+}
+
+#[async_trait::async_trait]
+impl wasmer_wasix::runtime::resolver::Source for MonitoringSource {
+    async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
+        self.progress.set_message(format!("Looking up {package}"));
+        self.inner.query(package).await
+    }
+}
+
+#[derive(Debug)]
+struct MonitoringPackageLoader {
+    inner: Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync>,
+    progress: ProgressBar,
+}
+
+#[async_trait::async_trait]
+impl wasmer_wasix::runtime::package_loader::PackageLoader for MonitoringPackageLoader {
+    async fn load(&self, summary: &PackageSummary) -> Result<Container, Error> {
+        let pkg_id = summary.package_id();
+        self.progress.set_message(format!("Downloading {pkg_id}"));
+
+        self.inner.load(summary).await
+    }
+
+    async fn load_package_tree(
+        &self,
+        root: &Container,
+        resolution: &wasmer_wasix::runtime::resolver::Resolution,
+        root_is_local_dir: bool,
+    ) -> Result<BinaryPackage, Error> {
+        self.inner
+            .load_package_tree(root, resolution, root_is_local_dir)
+            .await
+    }
+}
diff --git a/lib/cli/src/commands/run/target.rs b/lib/cli/src/commands/run/target.rs
new file mode 100644
index 0000000000..4bc06e7335
--- /dev/null
+++ b/lib/cli/src/commands/run/target.rs
@@ -0,0 +1,153 @@
+use std::{
+    fs::File,
+    io::Read as _,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::{Context as _, Error, bail};
+use indicatif::ProgressBar;
+use wasmer::Module;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::ArtifactBuild;
+use wasmer_types::ModuleHash;
+use wasmer_wasix::{
+    Runtime,
+    bin_factory::BinaryPackage,
+    runtime::{module_cache::HashedModuleData, task_manager::VirtualTaskManagerExt as _},
+};
+
+/// We've been given the path for a file... What does it contain and how should
+/// that be run?
+#[derive(Debug, Clone)]
+pub enum TargetOnDisk {
+    WebAssemblyBinary,
+    Wat,
+    LocalWebc,
+    Artifact,
+}
+
+impl TargetOnDisk {
+    pub fn from_file(path: &Path) -> Result<TargetOnDisk, Error> {
+        // Normally the first couple hundred bytes is enough to figure
+        // out what type of file this is.
+        let mut buffer = [0_u8; 512];
+
+        let mut f = File::open(path)
+            .with_context(|| format!("Unable to open \"{}\" for reading", path.display()))?;
+        let bytes_read = f.read(&mut buffer)?;
+
+        let leading_bytes = &buffer[..bytes_read];
+
+        if wasmer::is_wasm(leading_bytes) {
+            return Ok(TargetOnDisk::WebAssemblyBinary);
+        }
+
+        if webc::detect(leading_bytes).is_ok() {
+            return Ok(TargetOnDisk::LocalWebc);
+        }
+
+        #[cfg(feature = "compiler")]
+        if ArtifactBuild::is_deserializable(leading_bytes) {
+            return Ok(TargetOnDisk::Artifact);
+        }
+
+        // If we can't figure out the file type based on its content, fall back
+        // to checking the extension.
+
+        match path.extension().and_then(|s| s.to_str()) {
+            Some("wat") => Ok(TargetOnDisk::Wat),
+            Some("wasm") => Ok(TargetOnDisk::WebAssemblyBinary),
+            Some("webc") => Ok(TargetOnDisk::LocalWebc),
+            Some("wasmu") => Ok(TargetOnDisk::WebAssemblyBinary),
+            _ => bail!("Unable to determine how to execute \"{}\"", path.display()),
+        }
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Clone)]
+pub enum ExecutableTarget {
+    WebAssembly {
+        module: Module,
+        module_hash: ModuleHash,
+        path: PathBuf,
+    },
+    Package(Box<BinaryPackage>),
+}
+
+impl ExecutableTarget {
+    /// Try to load a Wasmer package from a directory containing a `wasmer.toml`
+    /// file.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn from_dir(
+        dir: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
+        pb.set_message(format!("Loading \"{}\" into memory", dir.display()));
+        pb.set_message("Resolving dependencies");
+        let inner_runtime = runtime.clone();
+        let pkg = runtime.task_manager().spawn_and_block_on({
+            let path = dir.to_path_buf();
+
+            async move { BinaryPackage::from_dir(&path, inner_runtime.as_ref()).await }
+        })??;
+
+        Ok(ExecutableTarget::Package(Box::new(pkg)))
+    }
+
+    /// Try to load a file into something that can be used to run it.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn from_file(
+        path: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
+        pb.set_message(format!("Loading from \"{}\"", path.display()));
+
+        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_hashed_module_sync(module_data, None)
+                    .with_context(|| format!("Unable to compile \"{}\"", path.display()))?;
+
+                Ok(ExecutableTarget::WebAssembly {
+                    module,
+                    module_hash,
+                    path: path.to_path_buf(),
+                })
+            }
+            TargetOnDisk::Artifact => {
+                let engine = runtime.engine();
+                pb.set_message("Deserializing pre-compiled WebAssembly module");
+                let module = unsafe { Module::deserialize_from_file(&engine, path)? };
+
+                let module_hash = module.info().hash.ok_or_else(|| {
+                    anyhow::Error::msg("module hash is not present in the artifact")
+                })?;
+
+                Ok(ExecutableTarget::WebAssembly {
+                    module,
+                    module_hash,
+                    path: path.to_path_buf(),
+                })
+            }
+            TargetOnDisk::LocalWebc => {
+                let container = wasmer_package::utils::from_disk(path)?;
+                pb.set_message("Resolving dependencies");
+
+                let inner_runtime = runtime.clone();
+                let pkg = runtime.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
+                })??;
+                Ok(ExecutableTarget::Package(Box::new(pkg)))
+            }
+        }
+    }
+}
diff --git a/lib/cli/src/commands/run/wasi.rs b/lib/cli/src/commands/run/wasi.rs
index b48ce6585a..112fa0a9e4 100644
--- a/lib/cli/src/commands/run/wasi.rs
+++ b/lib/cli/src/commands/run/wasi.rs
@@ -2,29 +2,32 @@ use std::{
     collections::{BTreeSet, HashMap},
     path::{Path, PathBuf},
     str::FromStr,
-    sync::{mpsc::Sender, Arc},
+    sync::{Arc, mpsc::Sender},
     time::Duration,
 };
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use bytes::Bytes;
 use clap::Parser;
+use itertools::Itertools;
 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};
 use wasmer_wasix::{
+    PluggableRuntime, RewindState, Runtime, WasiEnv, WasiEnvBuilder, WasiError, WasiFunctionEnv,
+    WasiVersion,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
     default_fs_backing, get_wasi_versions,
     http::HttpClient,
-    journal::{CompactingLogFileJournal, DynJournal},
-    os::{tty_sys::SysTty, TtyBridge},
+    journal::{CompactingLogFileJournal, DynJournal, DynReadableJournal},
+    os::{TtyBridge, tty_sys::SysTty},
     rewind_ext,
     runners::MAPPED_CURRENT_DIR_DEFAULT_PATH,
     runners::{MappedCommand, MappedDirectory},
@@ -35,21 +38,22 @@ use wasmer_wasix::{
             BackendSource, FileSystemSource, InMemorySource, MultiSource, Source, WebSource,
         },
         task_manager::{
-            tokio::{RuntimeOrHandle, TokioTaskManager},
             VirtualTaskManagerExt,
+            tokio::{RuntimeOrHandle, TokioTaskManager},
         },
     },
     types::__WASI_STDIN_FILENO,
     wasmer_wasix_types::wasi::Errno,
-    PluggableRuntime, RewindState, Runtime, WasiEnv, WasiEnvBuilder, WasiError, WasiFunctionEnv,
-    WasiVersion,
 };
 
-use crate::utils::{parse_envvar, parse_mapdir};
+use crate::{
+    config::{UserRegistry, WasmerEnv},
+    utils::{parse_envvar, parse_mapdir, parse_volume},
+};
 
 use super::{
+    CliPackageSource, ExecutableTarget,
     capabilities::{self, PkgCapabilityCache},
-    ExecutableTarget, PackageSource,
 };
 
 const WAPM_SOURCE_CACHE_TIMEOUT: Duration = Duration::from_secs(10 * 60);
@@ -57,18 +61,31 @@ const WAPM_SOURCE_CACHE_TIMEOUT: Duration = Duration::from_secs(10 * 60);
 #[derive(Debug, Parser, Clone, Default)]
 /// WASI Options
 pub struct Wasi {
-    /// WASI pre-opened directory
-    #[clap(long = "dir", name = "DIR", group = "wasi")]
+    /// Map a host directory to a different location for the Wasm module
+    #[clap(
+        long = "volume",
+        name = "[HOST_DIR:]GUEST_DIR",
+        value_parser = parse_volume,
+    )]
+    volumes: Vec<MappedDirectory>,
+
+    // Legacy option
+    #[clap(long = "dir", group = "wasi", hide = true)]
     pub(crate) pre_opened_directories: Vec<PathBuf>,
 
-    /// Map a host directory to a different location for the Wasm module
+    // Legacy option
     #[clap(
         long = "mapdir",
-        name = "GUEST_DIR:HOST_DIR",
-        value_parser=parse_mapdir,
-    )]
+        value_parser = parse_mapdir,
+        hide = true
+     )]
     pub(crate) mapped_dirs: Vec<MappedDirectory>,
 
+    /// Set the module's initial CWD to this path; does not work with
+    /// WASI preview 1 modules.
+    #[clap(long = "cwd")]
+    pub(crate) cwd: Option<PathBuf>,
+
     /// Pass custom environment variables
     #[clap(
         long = "env",
@@ -97,8 +114,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 +149,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 +168,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 +195,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 +212,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 +232,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 {
@@ -186,10 +248,17 @@ pub struct RunProperties {
     pub args: Vec<String>,
 }
 
+fn endpoint_to_folder(url: &Url) -> String {
+    url.to_string()
+        .replace("registry.wasmer.io", "wasmer.io")
+        .replace("registry.wasmer.wtf", "wasmer.wtf")
+        .replace(|c| "/:?&=#%\\".contains(c), "_")
+}
+
 #[allow(dead_code)]
 impl Wasi {
     pub fn map_dir(&mut self, alias: &str, target_on_disk: PathBuf) {
-        self.mapped_dirs.push(MappedDirectory {
+        self.volumes.push(MappedDirectory {
             guest: alias.to_string(),
             host: target_on_disk,
         });
@@ -215,6 +284,18 @@ impl Wasi {
         get_wasi_versions(module, false).is_some()
     }
 
+    pub(crate) fn all_volumes(&self) -> Vec<MappedDirectory> {
+        self.volumes
+            .iter()
+            .cloned()
+            .chain(self.pre_opened_directories.iter().map(|d| MappedDirectory {
+                host: d.clone(),
+                guest: d.to_str().expect("must be a valid path string").to_string(),
+            }))
+            .chain(self.mapped_dirs.iter().cloned())
+            .collect_vec()
+    }
+
     pub fn prepare(
         &self,
         module: &Module,
@@ -246,7 +327,7 @@ impl Wasi {
             uses.push(pkg);
         }
 
-        let builder = WasiEnv::builder(program_name)
+        let mut builder = WasiEnv::builder(program_name)
             .runtime(Arc::clone(&rt))
             .args(args)
             .envs(self.env_vars.clone())
@@ -259,91 +340,12 @@ impl Wasi {
                 .with_tty(Box::new(DeviceFile::new(__WASI_STDIN_FILENO)))
                 .build();
 
-            let mut mapped_dirs = Vec::new();
-
-            // Process the --dirs flag and merge it with --mapdir.
-            let mut have_current_dir = false;
-            for dir in &self.pre_opened_directories {
-                let mapping = if dir == Path::new(".") {
-                    if have_current_dir {
-                        bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
-                    }
-                    have_current_dir = true;
-
-                    let current_dir =
-                        std::env::current_dir().context("could not determine current directory")?;
-
-                    MappedDirectory {
-                        host: current_dir,
-                        guest: MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                    }
-                } else {
-                    let resolved = dir.canonicalize().with_context(|| {
-                        format!(
-                            "could not canonicalize path for argument '--dir {}'",
-                            dir.display()
-                        )
-                    })?;
-
-                    if &resolved != dir {
-                        bail!(
-                            "Invalid argument '--dir {}': path must either be absolute, or '.'",
-                            dir.display(),
-                        );
-                    }
-
-                    let guest = resolved
-                        .to_str()
-                        .with_context(|| {
-                            format!(
-                                "invalid argument '--dir {}': path must be valid utf-8",
-                                dir.display(),
-                            )
-                        })?
-                        .to_string();
-
-                    MappedDirectory {
-                        host: resolved,
-                        guest,
-                    }
-                };
-
-                mapped_dirs.push(mapping);
-            }
-
-            for MappedDirectory { host, guest } in &self.mapped_dirs {
-                let resolved_host = host.canonicalize().with_context(|| {
-                    format!(
-                        "could not canonicalize path for argument '--mapdir {}:{}'",
-                        host.display(),
-                        guest,
-                    )
-                })?;
-
-                let mapping = if guest == "." {
-                    if have_current_dir {
-                        bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
-                    }
-                    have_current_dir = true;
-
-                    MappedDirectory {
-                        host: resolved_host,
-                        guest: MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                    }
-                } else {
-                    MappedDirectory {
-                        host: resolved_host,
-                        guest: guest.clone(),
-                    }
-                };
-                mapped_dirs.push(mapping);
-            }
-
+            let (have_current_dir, mut mapped_dirs) = self.build_mapped_directories(false)?;
             if !mapped_dirs.is_empty() {
                 // TODO: should we expose the common ancestor instead of root?
                 let fs_backing: Arc<dyn FileSystem + Send + Sync> =
-                    Arc::new(PassthruFileSystem::new(default_fs_backing()));
-                for MappedDirectory { host, guest } in self.mapped_dirs.clone() {
+                    Arc::new(PassthruFileSystem::new_arc(default_fs_backing()));
+                for MappedDirectory { host, guest } in self.all_volumes() {
                     let host = if !host.is_absolute() {
                         Path::new("/").join(host)
                     } else {
@@ -353,16 +355,23 @@ impl Wasi {
                 }
             }
 
+            if let Some(cwd) = self.cwd.as_ref() {
+                if !cwd.starts_with("/") {
+                    bail!("The argument to --cwd must be an absolute path");
+                }
+                builder = builder.current_dir(cwd.clone());
+            }
+
             // Open the root of the new filesystem
-            let b = builder
+            builder = builder
                 .sandbox_fs(root_fs)
                 .preopen_dir(Path::new("/"))
                 .unwrap();
 
             if have_current_dir {
-                b.map_dir(".", MAPPED_CURRENT_DIR_DEFAULT_PATH)?
+                builder.map_dir(".", MAPPED_CURRENT_DIR_DEFAULT_PATH)?
             } else {
-                b.map_dir(".", "/")?
+                builder.map_dir(".", "/")?
             }
         };
 
@@ -376,18 +385,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 +427,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"))]
@@ -411,77 +442,49 @@ impl Wasi {
 
     pub fn build_mapped_directories(
         &self,
-    ) -> Result<(bool, bool, Vec<MappedDirectory>), anyhow::Error> {
+        is_wasix: bool,
+    ) -> Result<(bool, Vec<MappedDirectory>), anyhow::Error> {
         let mut mapped_dirs = Vec::new();
 
-        // Process the --dirs flag and merge it with --mapdir.
+        // Process the --volume flag.
         let mut have_current_dir = false;
-        for dir in &self.pre_opened_directories {
-            let mapping = if dir == Path::new(".") {
-                if have_current_dir {
-                    bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
-                }
-                have_current_dir = true;
-
-                let current_dir =
-                    std::env::current_dir().context("could not determine current directory")?;
-
-                MappedDirectory {
-                    host: current_dir,
-                    guest: MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
-                }
-            } else {
-                let resolved = dir.canonicalize().with_context(|| {
-                    format!(
-                        "could not canonicalize path for argument '--dir {}'",
-                        dir.display()
-                    )
-                })?;
-
-                if &resolved != dir {
-                    bail!(
-                        "Invalid argument '--dir {}': path must either be absolute, or '.'",
-                        dir.display(),
-                    );
-                }
-
-                let guest = resolved
-                    .to_str()
-                    .with_context(|| {
-                        format!(
-                            "invalid argument '--dir {}': path must be valid utf-8",
-                            dir.display(),
-                        )
-                    })?
-                    .to_string();
-
-                MappedDirectory {
-                    host: resolved,
-                    guest,
-                }
-            };
-
-            mapped_dirs.push(mapping);
-        }
-
-        for MappedDirectory { host, guest } in &self.mapped_dirs {
+        for MappedDirectory { host, guest } in &self.all_volumes() {
             let resolved_host = host.canonicalize().with_context(|| {
                 format!(
-                    "could not canonicalize path for argument '--mapdir {}:{}'",
+                    "could not canonicalize path for argument '--volume {}:{}'",
                     host.display(),
                     guest,
                 )
             })?;
 
+            if guest == "/" && is_wasix {
+                // Note: it appears we canonicalize the path before this point and showing the value of
+                // `host` in the error message may throw users off, so we use a placeholder.
+                tracing::warn!(
+                    "Mounting on the guest's virtual root with --volume <HOST_DIR>:/ breaks WASIX modules' filesystems"
+                );
+            }
+
             let mapping = if guest == "." {
                 if have_current_dir {
-                    bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
+                    bail!(
+                        "Cannot pre-open the current directory twice: '--volume=.' must only be specified once"
+                    );
                 }
                 have_current_dir = true;
 
+                let host = if host == Path::new(".") {
+                    std::env::current_dir().context("could not determine current directory")?
+                } else {
+                    host.clone()
+                };
                 MappedDirectory {
                     host: resolved_host,
-                    guest: MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
+                    guest: if is_wasix {
+                        MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string()
+                    } else {
+                        "/".to_string()
+                    },
                 }
             } else {
                 MappedDirectory {
@@ -492,9 +495,7 @@ impl Wasi {
             mapped_dirs.push(mapping);
         }
 
-        let is_tmp_mapped = mapped_dirs.iter().any(|d| d.guest == "/tmp");
-
-        Ok((have_current_dir, is_tmp_mapped, mapped_dirs))
+        Ok((have_current_dir, mapped_dirs))
     }
 
     pub fn build_mapped_commands(&self) -> Result<Vec<MappedCommand>, anyhow::Error> {
@@ -547,32 +548,51 @@ impl Wasi {
         pkg_cache_path: &Path,
         rt_or_handle: I,
         preferred_webc_version: webc::Version,
-    ) -> Result<impl Runtime + Send + Sync>
+    ) -> Result<impl Runtime + Send + Sync + use<I>>
     where
         I: Into<RuntimeOrHandle>,
     {
         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 +611,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)
     }
@@ -626,7 +648,13 @@ impl Wasi {
         Ok(Self {
             deny_multiple_wasi_versions: true,
             env_vars: std::env::vars().collect(),
-            pre_opened_directories: vec![dir],
+            volumes: vec![MappedDirectory {
+                host: dir.clone(),
+                guest: dir
+                    .to_str()
+                    .expect("dir must be a valid string")
+                    .to_string(),
+            }],
             ..Self::default()
         })
     }
@@ -635,7 +663,7 @@ impl Wasi {
         &self,
         env: &WasmerEnv,
         client: Arc<dyn HttpClient + Send + Sync>,
-    ) -> Result<impl PackageLoader + Send + Sync> {
+    ) -> Result<BuiltinPackageLoader> {
         let checkout_dir = env.cache_dir().join("checkouts");
         let tokens = tokens_by_authority(env)?;
 
@@ -652,8 +680,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<MultiSource> {
+        let mut source = MultiSource::default();
 
         // Note: This should be first so our "preloaded" sources get a chance to
         // override the main registry.
@@ -666,7 +694,10 @@ impl Wasi {
         source.add_source(preloaded);
 
         let graphql_endpoint = self.graphql_endpoint(env)?;
-        let cache_dir = env.cache_dir().join("queries");
+        let cache_dir = env
+            .cache_dir()
+            .join("queries")
+            .join(endpoint_to_folder(&graphql_endpoint));
         let mut wapm_source = BackendSource::new(graphql_endpoint, Arc::clone(&client))
             .with_local_cache(cache_dir, WAPM_SOURCE_CACHE_TIMEOUT)
             .with_preferred_webc_version(preferred_webc_version);
@@ -703,8 +734,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>> {
@@ -712,17 +742,17 @@ fn tokens_by_authority(env: &WasmerEnv) -> Result<HashMap<String, String>> {
     let config = env.config()?;
 
     for credentials in config.registry.tokens {
-        if let Ok(url) = Url::parse(&credentials.registry) {
-            if url.has_authority() {
-                tokens.insert(url.authority().to_string(), credentials.token);
-            }
+        if let Ok(url) = Url::parse(&credentials.registry)
+            && url.has_authority()
+        {
+            tokens.insert(url.authority().to_string(), credentials.token);
         }
     }
 
-    if let (Ok(current_registry), Some(token)) = (env.registry_endpoint(), env.token()) {
-        if current_registry.has_authority() {
-            tokens.insert(current_registry.authority().to_string(), token);
-        }
+    if let (Ok(current_registry), Some(token)) = (env.registry_endpoint(), env.token())
+        && current_registry.has_authority()
+    {
+        tokens.insert(current_registry.authority().to_string(), token);
     }
 
     // Note: The global wasmer.toml config file stores URLs for the GraphQL
@@ -739,10 +769,10 @@ fn tokens_by_authority(env: &WasmerEnv) -> Result<HashMap<String, String>> {
 
     let mut frontend_tokens = HashMap::new();
     for (hostname, token) in &tokens {
-        if let Some(frontend_url) = hostname.strip_prefix("registry.") {
-            if !tokens.contains_key(frontend_url) {
-                frontend_tokens.insert(frontend_url.to_string(), token.clone());
-            }
+        if let Some(frontend_url) = hostname.strip_prefix("registry.")
+            && !tokens.contains_key(frontend_url)
+        {
+            frontend_tokens.insert(frontend_url.to_string(), token.clone());
         }
     }
     tokens.extend(frontend_tokens);
diff --git a/lib/cli/src/commands/self_update.rs b/lib/cli/src/commands/self_update.rs
index dd74fa274a..0469c8f98c 100644
--- a/lib/cli/src/commands/self_update.rs
+++ b/lib/cli/src/commands/self_update.rs
@@ -32,6 +32,8 @@ impl SelfUpdate {
 
     #[cfg(target_os = "windows")]
     fn inner_execute(&self) -> Result<(), anyhow::Error> {
-        anyhow::bail!("Self update is not supported on Windows. Use install instructions on the Wasmer homepage: https://wasmer.io");
+        anyhow::bail!(
+            "Self update is not supported on Windows. Use install instructions on the Wasmer homepage: https://wasmer.io"
+        );
     }
 }
diff --git a/lib/cli/src/commands/ssh.rs b/lib/cli/src/commands/ssh.rs
index 046838d1fb..87fa02ad65 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::{WasmerClient, types::DeployApp};
 
-use super::AsyncCliCommand;
-use crate::{config::WasmerEnv, edge_config::EdgeConfig};
+use super::{AsyncCliCommand, app::AppIdentArgOpts};
+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,21 +106,17 @@ 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");
             for arg in cmd.get_args() {
-                print!(" {}", arg.to_string_lossy().as_ref());
+                print!(" {}", arg.to_string_lossy());
             }
             println!();
             return Ok(());
@@ -99,30 +126,58 @@ impl AsyncCliCommand for CmdSsh {
         if exit.success() {
             Ok(())
         } else {
-            Err(anyhow::anyhow!("ssh failed with status {}", exit))
+            Err(anyhow::anyhow!("ssh failed with status {exit}"))
         }
     }
 }
 
-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..4485a14074 100644
--- a/lib/cli/src/commands/validate.rs
+++ b/lib/cli/src/commands/validate.rs
@@ -1,11 +1,11 @@
 use std::path::PathBuf;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
-use wasmer::*;
-
-use crate::store::StoreOptions;
+use wasmer::{Module, is_wasm};
+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..dfdb1448f0 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);
@@ -44,6 +44,8 @@ static void pass_mapdir_arg(wasi_config_t *wasi_config, char *mapdir) {
   free(dir);
 }
 
+// TODO: port to new --volume option if we want to use it in the future
+
 // We try to parse out `--dir` and `--mapdir` ahead of time and process those
 // specially. All other arguments are passed to the guest program.
 static void handle_arguments(
@@ -124,7 +126,7 @@ int main(int argc, char *argv[]) {
       }
     }
     
-    // select the --command only if if was given before a "--", such 
+    // select the --command only if it was given before a "--", such 
     for (int i = 1; i < argc; i++) {
       if ((strcmp(argv[i], "--command") == 0 || strcmp(argv[i], "-c") == 0) && dash_dash_position > i) {
         // next arg is a command
diff --git a/lib/cli/src/commands/wast.rs b/lib/cli/src/commands/wast.rs
index a2ce63b789..f45baffc6a 100644
--- a/lib/cli/src/commands/wast.rs
+++ b/lib/cli/src/commands/wast.rs
@@ -3,10 +3,10 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use wasmer::NativeEngineExt;
+use wasmer::{Store, sys::Target};
 use wasmer_wast::Wast as WastSpectest;
 
-use crate::{common::HashAlgorithm, store::StoreOptions};
+use crate::backend::RuntimeOptions;
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer wast` subcommand
@@ -16,15 +16,11 @@ 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.
     fail_fast: bool,
-
-    /// Hashing algorithm to be used for module hash
-    #[clap(long, value_enum)]
-    hash_algorithm: Option<HashAlgorithm>,
 }
 
 impl Wast {
@@ -34,12 +30,9 @@ 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 = store.engine().clone();
-        let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
-        engine.set_hash_algorithm(Some(hash_algorithm));
+        let engine = self.rt.get_engine(&Target::default())?;
 
+        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..cdb476fd44 100644
--- a/lib/cli/src/common.rs
+++ b/lib/cli/src/common.rs
@@ -1,7 +1,7 @@
 //! Common module with common used structures across different
 //! commands.
 
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 
 #[derive(Debug, Parser, Clone, Default)]
 /// The WebAssembly features that can be passed through the
@@ -37,29 +37,5 @@ pub struct WasmFeatures {
 }
 
 pub(crate) fn normalize_path(s: &str) -> String {
-    wasmer_registry::utils::normalize_path(s)
-}
-
-/// Hashing algorithm to be used for the module info
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, ValueEnum)]
-pub enum HashAlgorithm {
-    /// Sha256
-    Sha256,
-    /// XXHash
-    XXHash,
-}
-
-impl Default for HashAlgorithm {
-    fn default() -> Self {
-        Self::Sha256
-    }
-}
-
-impl From<HashAlgorithm> for wasmer_types::HashAlgorithm {
-    fn from(value: HashAlgorithm) -> Self {
-        match value {
-            HashAlgorithm::Sha256 => wasmer_types::HashAlgorithm::Sha256,
-            HashAlgorithm::XXHash => wasmer_types::HashAlgorithm::XXHash,
-        }
-    }
+    s.strip_prefix(r"\\?\").unwrap_or(s).to_string()
 }
diff --git a/lib/cli/src/config/env.rs b/lib/cli/src/config/env.rs
index 496962c14f..99728b8ef2 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".
 ///
@@ -24,8 +22,7 @@ pub struct WasmerEnv {
     #[clap(long, env = "WASMER_CACHE_DIR", default_value = super::DEFAULT_WASMER_CACHE_DIR.as_os_str())]
     pub(crate) cache_dir: PathBuf,
 
-    /// The registry to fetch packages from (inferred from the environment by
-    /// default)
+    /// Change the current registry
     #[clap(long, env = "WASMER_REGISTRY")]
     pub(crate) registry: Option<UserRegistry>,
 
@@ -36,6 +33,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 +91,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 +136,30 @@ 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 '{domain}': unknown backend"
+            );
+        }
     }
 
-    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,
@@ -161,7 +177,9 @@ impl WasmerEnv {
     pub fn client(&self) -> Result<WasmerClient, anyhow::Error> {
         let client = self.client_unauthennticated()?;
         if client.auth_token().is_none() {
-            anyhow::bail!("no token provided - run 'wasmer login', specify --token=XXX, or set the WASMER_TOKEN env var");
+            anyhow::bail!(
+                "no token provided - run 'wasmer login', specify --token=XXX, or set the WASMER_TOKEN env var"
+            );
         }
 
         Ok(client)
@@ -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..55824d1def 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>,
@@ -69,6 +81,7 @@ impl Default for MultiRegistry {
     }
 }
 
+#[allow(unused)]
 #[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
 pub struct Registry {
     pub url: String,
@@ -112,7 +125,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)]
@@ -167,8 +182,8 @@ impl MultiRegistry {
         let registry_formatted = format_graphql(registry);
         self.tokens
             .iter()
-            .filter(|login| login.registry == registry || login.registry == registry_formatted)
-            .last()
+            .rev()
+            .find(|login| login.registry == registry || login.registry == registry_formatted)
             .map(|login| login.token.clone())
     }
 
diff --git a/lib/cli/src/edge_config.rs b/lib/cli/src/edge_config.rs
index b9176e3f12..fc12c7e914 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 anyhow::{Context, bail};
 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>,
 }
@@ -25,21 +35,50 @@ impl EdgeConfig {
             .context("invalid client config: no 'version' key found")?;
 
         if version != Self::VERSION as i64 {
-            bail!(
-                "Invalid client config: unknown config version '{}'",
-                version
-            );
+            bail!("Invalid client config: unknown config version '{version}'");
         }
 
         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 +94,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);
@@ -101,19 +134,19 @@ pub fn load_config(custom_path: Option<PathBuf>) -> Result<LoadedEdgeConfig, any
         None
     };
 
-    if let Some(path) = path {
-        if path.is_file() {
-            match try_load_config(&path) {
-                Ok(config) => {
-                    return Ok(LoadedEdgeConfig { config, path });
-                }
-                Err(err) => {
-                    eprintln!(
-                        "WARNING: failed to load config file at '{}': {}",
-                        path.display(),
-                        err
-                    );
-                }
+    if let Some(path) = path
+        && path.is_file()
+    {
+        match try_load_config(&path) {
+            Ok(config) => {
+                return Ok(LoadedEdgeConfig { config, path });
+            }
+            Err(err) => {
+                eprintln!(
+                    "WARNING: failed to load config file at '{}': {}",
+                    path.display(),
+                    err
+                );
             }
         }
     }
@@ -131,3 +164,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..cdf22c4975 100644
--- a/lib/cli/src/lib.rs
+++ b/lib/cli/src/lib.rs
@@ -13,21 +13,21 @@
 )]
 // Allowed because it makes code more readable.
 #![allow(clippy::bool_comparison, clippy::match_like_matches_macro)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_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..c67343d7c5 100644
--- a/lib/cli/src/logging.rs
+++ b/lib/cli/src/logging.rs
@@ -1,8 +1,8 @@
 //! Logging functions for the debug feature.
 
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter, Layer, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 const WHITELISTED_LOG_TARGETS: &[&str] = &["wasmer", "wasmer_wasix", "virtual_fs"];
 
@@ -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,
@@ -29,28 +32,48 @@ impl Output {
         self.verbose > 0
     }
 
+    /// Returns true if either the `--quiet` flag is set or stderr is not a TTY.
+    pub fn is_quiet_or_no_tty(&self) -> bool {
+        self.quiet || !std::io::stderr().is_terminal()
+    }
+
     /// Initialize logging based on the `$RUST_LOG` environment variable and
     /// command-line flags.
     pub fn initialize_logging(&self) {
+        let filter_layer = self.log_filter();
+
         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 filter_layer = self.log_filter();
+        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 registry = tracing_subscriber::registry();
+
+        #[cfg(feature = "tokio-subscriber")]
+        let registry = registry.with(console_subscriber::spawn());
 
         match self.log_format {
-            LogFormat::Text => tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer.compact().with_target(true))
+            LogFormat::Text => registry
+                .with(
+                    fmt_layer
+                        .compact()
+                        .with_target(true)
+                        .with_filter(filter_layer),
+                )
                 .init(),
-            LogFormat::Json => tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer.json().with_target(true))
+            LogFormat::Json => registry
+                .with(fmt_layer.json().with_target(true).with_filter(filter_layer))
                 .init(),
-        }
+        };
     }
 
     fn log_filter(&self) -> EnvFilter {
@@ -125,3 +148,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
deleted file mode 100644
index 4c54b1ab7e..0000000000
--- a/lib/cli/src/package_source.rs
+++ /dev/null
@@ -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..6208bfd731 100644
--- a/lib/cli/src/utils/mod.rs
+++ b/lib/cli/src/utils/mod.rs
@@ -3,46 +3,54 @@
 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},
-    str::FromStr,
-};
+use std::path::{Path, PathBuf};
 
-use anyhow::{bail, Context as _, Result};
-use once_cell::sync::Lazy;
-use regex::Regex;
+use anyhow::{Context as _, Result, bail};
+use itertools::Itertools;
 use wasmer_wasix::runners::MappedDirectory;
 
-fn retrieve_alias_pathbuf(alias: &str, real_dir: &str) -> Result<MappedDirectory> {
-    let pb = PathBuf::from(&real_dir).canonicalize()?;
-    if let Ok(pb_metadata) = pb.metadata() {
+fn retrieve_alias_pathbuf(host_dir: &str, guest_dir: &str) -> Result<MappedDirectory> {
+    let host_dir_path = PathBuf::from(&host_dir).canonicalize()?;
+    if let Ok(pb_metadata) = host_dir_path.metadata() {
         if !pb_metadata.is_dir() {
-            bail!("\"{}\" exists, but it is not a directory", &real_dir);
+            bail!("\"{}\" exists, but it is not a directory", &host_dir);
         }
     } else {
-        bail!("Directory \"{}\" does not exist", &real_dir);
+        bail!("Directory \"{}\" does not exist", &host_dir);
     }
     Ok(MappedDirectory {
-        guest: alias.to_string(),
-        host: pb,
+        host: host_dir_path,
+        guest: guest_dir.to_string(),
     })
 }
 
-/// Parses a mapdir from a string
-pub fn parse_mapdir(entry: &str) -> Result<MappedDirectory> {
-    // We try first splitting by `::`
-    if let [alias, real_dir] = entry.split("::").collect::<Vec<&str>>()[..] {
-        retrieve_alias_pathbuf(alias, real_dir)
+/// Parses a volume from a string
+pub fn parse_volume(entry: &str) -> Result<MappedDirectory> {
+    let components = entry.split(":").collect_vec();
+    match components.as_slice() {
+        [entry] => retrieve_alias_pathbuf(entry, entry),
+        [host_dir, guest_dir] => retrieve_alias_pathbuf(host_dir, guest_dir),
+        _ => bail!(
+            "Directory mappings must consist of a single path, or two paths separate by a `:`. Found {}",
+            &entry
+        ),
     }
-    // And then we try splitting by `:` (for compatibility with previous API)
-    else if let [alias, real_dir] = entry.splitn(2, ':').collect::<Vec<&str>>()[..] {
-        retrieve_alias_pathbuf(alias, real_dir)
-    } else {
-        bail!(
-            "Directory mappings must consist of two paths separate by a `::` or `:`. Found {}",
+}
+
+/// Parses a mapdir(legacy option) from a string.
+pub fn parse_mapdir(entry: &str) -> Result<MappedDirectory> {
+    let components = entry.split(":").collect_vec();
+    match components.as_slice() {
+        [entry] => retrieve_alias_pathbuf(entry, entry),
+        // swapper order compared to the --volume option
+        [guest_dir, host_dir] => retrieve_alias_pathbuf(host_dir, guest_dir),
+        _ => bail!(
+            "Directory mappings must consist of a single path, or two paths separate by a `:`. Found {}",
             &entry
-        )
+        ),
     }
 }
 
@@ -93,7 +101,7 @@ pub fn load_package_manifest(
                     "Could not read package manifest at '{}'",
                     file_path.display()
                 )
-            })
+            });
         }
     };
 
@@ -108,78 +116,6 @@ pub fn load_package_manifest(
     Ok(Some((file_path, manifest)))
 }
 
-/// The identifier for an app or package in the form, `owner/package@version`,
-/// where the `owner` and `version` are optional.
-#[derive(Debug, Clone, PartialEq)]
-pub(crate) struct Identifier {
-    /// The package's name.
-    pub name: String,
-    /// The package's owner, typically a username or namespace.
-    pub owner: Option<String>,
-    /// The package's version number.
-    pub version: Option<String>,
-}
-
-impl Identifier {
-    pub fn new(name: impl Into<String>) -> Self {
-        Identifier {
-            name: name.into(),
-            owner: None,
-            version: None,
-        }
-    }
-
-    pub fn with_owner(self, owner: impl Into<String>) -> Self {
-        Identifier {
-            owner: Some(owner.into()),
-            ..self
-        }
-    }
-
-    pub fn with_version(self, version: impl Into<String>) -> Self {
-        Identifier {
-            version: Some(version.into()),
-            ..self
-        }
-    }
-}
-
-impl FromStr for Identifier {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        const PATTERN: &str = r"^(?x)
-            (?:
-                (?P<owner>[a-zA-Z][\w\d_.-]*)
-                /
-            )?
-            (?P<name>[a-zA-Z][\w\d_.-]*)
-            (?:
-                @
-                (?P<version>[\w\d.]+)
-            )?
-            $
-        ";
-        static RE: Lazy<Regex> = Lazy::new(|| Regex::new(PATTERN).unwrap());
-
-        let caps = RE.captures(s).context(
-            "Invalid package identifier, expected something like namespace/package@version",
-        )?;
-
-        let mut identifier = Identifier::new(&caps["name"]);
-
-        if let Some(owner) = caps.name("owner") {
-            identifier = identifier.with_owner(owner.as_str());
-        }
-
-        if let Some(version) = caps.name("version") {
-            identifier = identifier.with_version(version.as_str());
-        }
-
-        Ok(identifier)
-    }
-}
-
 /// Merge two yaml values by recursively merging maps from b into a.
 ///
 /// Preserves old values that were not in b.
@@ -247,46 +183,6 @@ c: c
         assert_eq!(merged, c);
     }
 
-    #[test]
-    fn parse_valid_identifiers() {
-        let inputs = [
-            ("python", Identifier::new("python")),
-            (
-                "syrusakbary/python",
-                Identifier::new("python").with_owner("syrusakbary"),
-            ),
-            (
-                "wasmer/wasmer.io",
-                Identifier::new("wasmer.io").with_owner("wasmer"),
-            ),
-            (
-                "syrusakbary/python@1.2.3",
-                Identifier::new("python")
-                    .with_owner("syrusakbary")
-                    .with_version("1.2.3"),
-            ),
-            (
-                "python@1.2.3",
-                Identifier::new("python").with_version("1.2.3"),
-            ),
-        ];
-
-        for (src, expected) in inputs {
-            let identifier = Identifier::from_str(src).expect(src);
-            assert_eq!(identifier, expected);
-        }
-    }
-
-    #[test]
-    fn invalid_package_identifiers() {
-        let inputs = ["", "$", "python/", "/python", "python@", "."];
-
-        for input in inputs {
-            let result = Identifier::from_str(input);
-            assert!(result.is_err(), "Got {result:?} from {input:?}");
-        }
-    }
-
     #[test]
     fn test_parse_envvar() {
         assert_eq!(
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..f5754ce6df 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 dialoguer::{Select, theme::ColorfulTheme};
+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..d9e4b109ed
--- /dev/null
+++ b/lib/cli/src/utils/timestamp.rs
@@ -0,0 +1,68 @@
+use time::{
+    Date, OffsetDateTime, PrimitiveDateTime, Time,
+    format_description::well_known::{Rfc2822, Rfc3339},
+};
+
+/// 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/cli/tests/version.rs b/lib/cli/tests/version.rs
index 1dcb7e8307..62558358fb 100644
--- a/lib/cli/tests/version.rs
+++ b/lib/cli/tests/version.rs
@@ -1,4 +1,5 @@
-use assert_cmd::Command;
+use assert_cmd::cargo::cargo_bin_cmd;
+use git_version::git_version;
 
 const WASMER_VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -6,15 +7,13 @@ const WASMER_VERSION: &str = env!("CARGO_PKG_VERSION");
 fn short_version_string() {
     let version_number = format!("wasmer {WASMER_VERSION}");
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("--version")
         .assert()
         .success()
         .stdout(predicates::str::contains(&version_number));
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("-V")
         .assert()
         .success()
@@ -26,12 +25,14 @@ fn long_version_string() {
     let long_version_number = format!(
         "wasmer {} ({} {})",
         env!("CARGO_PKG_VERSION"),
-        env!("WASMER_BUILD_GIT_HASH_SHORT"),
+        git_version!(
+            args = ["--abbrev=8", "--always", "--dirty=-modified", "--exclude=*"],
+            fallback = ""
+        ),
         env!("WASMER_BUILD_DATE")
     );
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("--version")
         .arg("--verbose")
         .assert()
@@ -39,8 +40,7 @@ fn long_version_string() {
         .stdout(predicates::str::contains(&long_version_number))
         .stdout(predicates::str::contains("binary:"));
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("-Vv")
         .assert()
         .success()
@@ -52,15 +52,13 @@ fn long_version_string() {
 fn help_text_contains_version() {
     let version_number = format!("wasmer {WASMER_VERSION}");
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("-h")
         .assert()
         .success()
         .stdout(predicates::str::contains(&version_number));
 
-    Command::cargo_bin("wasmer")
-        .unwrap()
+    cargo_bin_cmd!("wasmer")
         .arg("--help")
         .assert()
         .success()
diff --git a/lib/compiler-cranelift/Cargo.toml b/lib/compiler-cranelift/Cargo.toml
index 805f53319c..18c6ff7e51 100644
--- a/lib/compiler-cranelift/Cargo.toml
+++ b/lib/compiler-cranelift/Cargo.toml
@@ -14,22 +14,35 @@ 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 = "=7.0.0", default-features = false, features = [
+	"translator",
+	"compiler",
+] }
+wasmer-types = { path = "../types", version = "=7.0.0", default-features = false, features = [
+	"std",
+] }
+
+cranelift-entity.workspace = true
+cranelift-codegen = { workspace = true, features = [
+	"x86",
+	"arm64",
+	"riscv64",
+] }
+cranelift-frontend.workspace = true
+
+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
+leb128.workspace = true
+indexmap.workspace = true
 
 [dev-dependencies]
-cranelift-codegen = { version = "0.91.1", features = ["all-arch"] }
-lazy_static = "1.4"
+cranelift-codegen = { workspace = true, features = ["all-arch"] }
 
 [badges]
 maintenance = { status = "actively-developed" }
@@ -38,8 +51,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
deleted file mode 100644
index 0be0760c07..0000000000
--- a/lib/compiler-cranelift/build.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//! Wasmer Cranelift compiler build script.
-//!
-//! Sets the git revsion? for $PURPOSE
-//! TODO(syrus): explain what's happening here
-
-use std::process::Command;
-use std::str;
-
-fn main() {
-    let git_rev = match Command::new("git").args(["rev-parse", "HEAD"]).output() {
-        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);
-}
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..4dbede28d3 100644
--- a/lib/compiler-cranelift/src/compiler.rs
+++ b/lib/compiler-cranelift/src/compiler.rs
@@ -1,39 +1,70 @@
 //! 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,
+
+#[cfg(feature = "unwind")]
+use crate::eh::{build_function_lsda, build_lsda_section, build_tag_section};
+
+#[cfg(feature = "unwind")]
+use crate::translator::CraneliftUnwindInfo;
+use crate::{
+    address_map::get_function_address_map,
+    config::Cranelift,
+    func_environ::{FuncEnvironment, get_function_name},
+    trampoline::{
+        FunctionBuilderContext, make_trampoline_dynamic_function, make_trampoline_function_call,
+    },
+    translator::{
+        FuncTranslator, compiled_function_unwind_info, irlibcall_to_libcall,
+        irreloc_to_relocationkind, signature_to_cranelift_ir,
+    },
 };
-use crate::translator::{
-    compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
-    signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
+use cranelift_codegen::{
+    Context, FinalizedMachReloc, FinalizedRelocTarget, MachTrap,
+    ir::{self, ExternalName, UserFuncName},
 };
-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::{
+    constants::DW_EH_PE_absptr,
+    write::{Address, EhFrame, FrameTable, Writer},
+};
+
 #[cfg(feature = "rayon")]
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
+#[cfg(feature = "unwind")]
+use std::collections::HashMap;
 use std::sync::Arc;
+
+use wasmer_compiler::progress::ProgressContext;
+#[cfg(feature = "unwind")]
+use wasmer_compiler::types::{section::SectionIndex, unwind::CompiledFunctionUnwindInfo};
 use wasmer_compiler::{
     Compiler, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader, ModuleMiddleware,
     ModuleMiddlewareChain, ModuleTranslationState,
+    types::{
+        function::{
+            Compilation, CompiledFunction, CompiledFunctionFrameInfo, FunctionBody, UnwindInfo,
+        },
+        module::CompileModuleInfo,
+        relocation::{Relocation, RelocationTarget},
+    },
 };
-use wasmer_types::entity::{EntityRef, PrimaryMap};
+#[cfg(feature = "unwind")]
+use wasmer_types::entity::EntityRef;
+use wasmer_types::entity::PrimaryMap;
+#[cfg(feature = "unwind")]
+use wasmer_types::target::CallingConvention;
+use wasmer_types::target::Target;
 use wasmer_types::{
-    CallingConvention, Compilation, CompileError, CompileModuleInfo, CompiledFunction,
-    CompiledFunctionFrameInfo, CompiledFunctionUnwindInfo, Dwarf, FunctionBody, FunctionIndex,
-    LocalFunctionIndex, ModuleInfo, Relocation, RelocationTarget, SectionIndex, SignatureIndex,
-    Target, TrapCode, TrapInformation,
+    CompilationProgressCallback, 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,32 +79,24 @@ 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,
         module_translation_state: &ModuleTranslationState,
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
     ) -> Result<Compilation, CompileError> {
         let isa = self
             .config()
             .isa(target)
             .map_err(|error| CompileError::Codegen(error.to_string()))?;
         let frontend_config = isa.frontend_config();
+        #[cfg(feature = "unwind")]
+        let pointer_bytes = frontend_config.pointer_bytes();
         let memory_styles = &compile_info.memory_styles;
         let table_styles = &compile_info.table_styles;
         let module = &compile_info.module;
@@ -83,6 +106,15 @@ impl Compiler for CraneliftCompiler {
             .map(|(_sig_index, func_type)| signature_to_cranelift_ir(func_type, frontend_config))
             .collect::<PrimaryMap<SignatureIndex, ir::Signature>>();
 
+        let total_functions = function_body_inputs.len() as u64;
+        let total_function_call_trampolines = module.signatures.len() as u64;
+        let total_dynamic_trampolines = module.num_imported_functions as u64;
+        let total_steps =
+            total_functions + total_function_call_trampolines + total_dynamic_trampolines;
+        let progress = progress_callback
+            .cloned()
+            .map(|cb| ProgressContext::new(cb, total_steps, "cranelift::functions"));
+
         // Generate the frametable
         #[cfg(feature = "unwind")]
         let dwarf_frametable = if function_body_inputs.is_empty() {
@@ -92,41 +124,42 @@ impl Compiler for CraneliftCompiler {
             None
         } else {
             match target.triple().default_calling_convention() {
-                Ok(CallingConvention::SystemV) => {
-                    match isa.create_systemv_cie() {
-                        Some(cie) => {
-                            let mut dwarf_frametable = FrameTable::default();
-                            let cie_id = dwarf_frametable.add_cie(cie);
-                            Some((dwarf_frametable, cie_id))
-                        }
-                        // Even though we are in a SystemV system, Cranelift doesn't support it
-                        None => None,
+                Ok(CallingConvention::SystemV) => match isa.create_systemv_cie() {
+                    Some(mut cie) => {
+                        cie.personality = Some((
+                            DW_EH_PE_absptr,
+                            Address::Symbol {
+                                symbol: WriterRelocate::PERSONALITY_SYMBOL,
+                                addend: 0,
+                            },
+                        ));
+                        cie.lsda_encoding = Some(DW_EH_PE_absptr);
+                        let mut dwarf_frametable = FrameTable::default();
+                        let cie_id = dwarf_frametable.add_cie(cie);
+                        Some((dwarf_frametable, cie_id))
                     }
-                }
+                    // Even though we are in a SystemV system, Cranelift doesn't support it
+                    None => None,
+                },
                 _ => None,
             }
         };
 
-        let mut custom_sections = PrimaryMap::new();
-
-        #[cfg(not(feature = "rayon"))]
-        let mut func_translator = FuncTranslator::new();
-        #[cfg(not(feature = "rayon"))]
-        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
-            .iter()
-            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
-            .into_iter()
-            .map(|(i, input)| {
-                let func_index = module.func_index(i);
+        // The `compile_function` closure is used for both the sequential and
+        // parallel compilation paths to avoid code duplication.
+        let compile_function =
+            |func_translator: &mut FuncTranslator,
+             (i, input): (&LocalFunctionIndex, &FunctionBodyData)| {
+                let func_index = module.func_index(*i);
                 let mut context = Context::new();
                 let mut func_env = FuncEnvironment::new(
                     isa.frontend_config(),
                     module,
                     &signatures,
-                    &memory_styles,
-                    &table_styles,
+                    memory_styles,
+                    table_styles,
                 );
-                context.func.name = match get_function_name(func_index) {
+                context.func.name = match get_function_name(&mut context.func, func_index) {
                     ExternalName::User(nameref) => {
                         if context.func.params.user_named_funcs().is_valid(nameref) {
                             let name = &context.func.params.user_named_funcs()[nameref];
@@ -142,12 +175,13 @@ 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(
                     self.config
                         .middlewares
-                        .generate_function_middleware_chain(i),
+                        .generate_function_middleware_chain(*i),
                 );
 
                 func_translator.translate(
@@ -155,29 +189,71 @@ impl Compiler for CraneliftCompiler {
                     &mut reader,
                     &mut context.func,
                     &mut func_env,
-                    i,
+                    *i,
                 )?;
 
+                if let Some(callbacks) = self.config.callbacks.as_ref() {
+                    use wasmer_compiler::misc::CompiledKind;
+
+                    callbacks.preopt_ir(
+                        &CompiledKind::Local(*i, compile_info.module.get_function_name(func_index)),
+                        &compile_info.module.hash_string(),
+                        context.func.display().to_string().as_bytes(),
+                    );
+                }
+
                 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()))?;
+                let mut ctrl_plane = Default::default();
+                let func_name_map = context.func.params.user_named_funcs().clone();
+                let result = context
+                    .compile(&*isa, &mut ctrl_plane)
+                    .map_err(|error| CompileError::Codegen(format!("{error:#?}")))?;
+                code_buf.extend_from_slice(result.code_buffer());
+
+                if let Some(callbacks) = self.config.callbacks.as_ref() {
+                    use wasmer_compiler::misc::CompiledKind;
+
+                    callbacks.obj_memory_buffer(
+                        &CompiledKind::Local(*i, compile_info.module.get_function_name(func_index)),
+                        &compile_info.module.hash_string(),
+                        &code_buf,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::Local(*i, compile_info.module.get_function_name(func_index)),
+                        &compile_info.module.hash_string(),
+                        target.triple().architecture,
+                        &code_buf,
+                    )?;
+                }
 
-                let result = context.compiled_code().unwrap();
                 let func_relocs = result
                     .buffer
                     .relocs()
-                    .into_iter()
-                    .map(|r| mach_reloc_to_reloc(module, r))
+                    .iter()
+                    .map(|r| mach_reloc_to_reloc(module, &func_name_map, r))
                     .collect::<Vec<_>>();
 
                 let traps = result
                     .buffer
                     .traps()
-                    .into_iter()
+                    .iter()
                     .map(mach_trap_to_trap)
                     .collect::<Vec<_>>();
 
+                #[cfg(feature = "unwind")]
+                let function_lsda = if dwarf_frametable.is_some() {
+                    build_function_lsda(
+                        result.buffer.call_sites(),
+                        result.buffer.data().len(),
+                        pointer_bytes,
+                    )
+                } else {
+                    None
+                };
+
+                #[cfg(not(feature = "unwind"))]
+                let function_lsda = ();
+
                 let (unwind_info, fde) = match compiled_function_unwind_info(&*isa, &context)? {
                     #[cfg(feature = "unwind")]
                     CraneliftUnwindInfo::Fde(fde) => {
@@ -208,6 +284,10 @@ impl Compiler for CraneliftCompiler {
                 let range = reader.range();
                 let address_map = get_function_address_map(&context, range, code_buf.len());
 
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+
                 Ok((
                     CompiledFunction {
                         body: FunctionBody {
@@ -218,140 +298,122 @@ impl Compiler for CraneliftCompiler {
                         frame_info: CompiledFunctionFrameInfo { address_map, traps },
                     },
                     fde,
+                    function_lsda,
                 ))
-            })
-            .collect::<Result<Vec<_>, CompileError>>()?
+            };
+
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
+        let mut custom_sections = PrimaryMap::new();
+
+        #[cfg(not(feature = "rayon"))]
+        let mut func_translator = FuncTranslator::new();
+        #[cfg(not(feature = "rayon"))]
+        let results = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
             .into_iter()
-            .unzip();
+            .map(|(i, input)| compile_function(&mut func_translator, (&i, input)))
+            .collect::<Result<Vec<_>, CompileError>>()?;
         #[cfg(feature = "rayon")]
-        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+        let results = function_body_inputs
             .iter()
             .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
             .par_iter()
-            .map_init(FuncTranslator::new, |func_translator, (i, input)| {
-                let func_index = module.func_index(*i);
-                let mut context = Context::new();
-                let mut func_env = FuncEnvironment::new(
-                    isa.frontend_config(),
-                    module,
-                    &signatures,
-                    memory_styles,
-                    table_styles,
-                );
-                context.func.name = match get_function_name(func_index) {
-                    ExternalName::User(nameref) => {
-                        if context.func.params.user_named_funcs().is_valid(nameref) {
-                            let name = &context.func.params.user_named_funcs()[nameref];
-                            UserFuncName::User(name.clone())
-                        } else {
-                            UserFuncName::default()
-                        }
-                    }
-                    ExternalName::TestCase(testcase) => UserFuncName::Testcase(testcase),
-                    _ => UserFuncName::default(),
-                };
-                context.func.signature = signatures[module.functions[func_index]].clone();
-                // 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(
-                    self.config
-                        .middlewares
-                        .generate_function_middleware_chain(*i),
-                );
+            .map_init(FuncTranslator::new, |func_translator, &(i, input)| {
+                compile_function(func_translator, (&i, input))
+            })
+            .collect::<Result<Vec<_>, CompileError>>()?;
 
-                func_translator.translate(
-                    module_translation_state,
-                    &mut reader,
-                    &mut context.func,
-                    &mut func_env,
-                    *i,
-                )?;
+        let mut functions = Vec::with_capacity(function_body_inputs.len());
+        let mut fdes = Vec::with_capacity(function_body_inputs.len());
+        let mut lsda_data = Vec::with_capacity(function_body_inputs.len());
 
-                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()))?;
+        for (func, fde, lsda) in results {
+            functions.push(func);
+            fdes.push(fde);
+            lsda_data.push(lsda);
+        }
 
-                let result = context.compiled_code().unwrap();
-                let func_relocs = result
-                    .buffer
-                    .relocs()
-                    .iter()
-                    .map(|r| mach_reloc_to_reloc(module, r))
-                    .collect::<Vec<_>>();
+        #[cfg(feature = "unwind")]
+        let (_tag_section_index, lsda_section_index, function_lsda_offsets) =
+            if dwarf_frametable.is_some() {
+                let mut tag_section_index = None;
+                let mut tag_offsets = HashMap::new();
+                if let Some((tag_section, offsets)) = build_tag_section(&lsda_data) {
+                    custom_sections.push(tag_section);
+                    tag_section_index = Some(SectionIndex::new(custom_sections.len() - 1));
+                    tag_offsets = offsets;
+                }
+                let lsda_vec = lsda_data;
+                let (lsda_section, offsets_per_function) =
+                    build_lsda_section(lsda_vec, pointer_bytes, &tag_offsets, tag_section_index);
+                let mut lsda_section_index = None;
+                if let Some(section) = lsda_section {
+                    custom_sections.push(section);
+                    lsda_section_index = Some(SectionIndex::new(custom_sections.len() - 1));
+                }
+                (tag_section_index, lsda_section_index, offsets_per_function)
+            } else {
+                (None, None, vec![None; functions.len()])
+            };
 
-                let traps = result
-                    .buffer
-                    .traps()
-                    .iter()
-                    .map(mach_trap_to_trap)
-                    .collect::<Vec<_>>();
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
+        let mut unwind_info = UnwindInfo::default();
 
-                let (unwind_info, fde) = match compiled_function_unwind_info(&*isa, &context)? {
-                    #[cfg(feature = "unwind")]
-                    CraneliftUnwindInfo::Fde(fde) => {
-                        if dwarf_frametable.is_some() {
-                            let fde = fde.to_fde(Address::Symbol {
-                                // The symbol is the kind of relocation.
-                                // "0" is used for functions
-                                symbol: WriterRelocate::FUNCTION_SYMBOL,
-                                // We use the addend as a way to specify the
-                                // function index
-                                addend: i.index() as _,
-                            });
-                            // The unwind information is inserted into the dwarf section
-                            (Some(CompiledFunctionUnwindInfo::Dwarf), Some(fde))
+        #[cfg(feature = "unwind")]
+        if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
+            for (func_idx, fde_opt) in fdes.into_iter().enumerate() {
+                if let Some(mut fde) = fde_opt {
+                    let has_lsda = function_lsda_offsets
+                        .get(func_idx)
+                        .and_then(|v| *v)
+                        .is_some();
+                    let lsda_address = if has_lsda {
+                        debug_assert!(
+                            lsda_section_index.is_some(),
+                            "LSDA offsets require an LSDA section"
+                        );
+                        if lsda_section_index.is_some() {
+                            let symbol =
+                                WriterRelocate::lsda_symbol(LocalFunctionIndex::new(func_idx));
+                            Address::Symbol { symbol, addend: 0 }
                         } else {
-                            (None, None)
+                            Address::Constant(0)
                         }
-                    }
-                    #[cfg(feature = "unwind")]
-                    other => (other.maybe_into_to_windows_unwind(), None),
-
-                    // This is a bit hacky, but necessary since gimli is not
-                    // available when the "unwind" feature is disabled.
-                    #[cfg(not(feature = "unwind"))]
-                    other => (other.maybe_into_to_windows_unwind(), None::<()>),
-                };
-
-                let range = reader.range();
-                let address_map = get_function_address_map(&context, range, code_buf.len());
-
-                Ok((
-                    CompiledFunction {
-                        body: FunctionBody {
-                            body: code_buf,
-                            unwind_info,
-                        },
-                        relocations: func_relocs,
-                        frame_info: CompiledFunctionFrameInfo { address_map, traps },
-                    },
-                    fde,
-                ))
-            })
-            .collect::<Result<Vec<_>, CompileError>>()?
-            .into_iter()
-            .unzip();
+                    } else {
+                        Address::Constant(0)
+                    };
+                    fde.lsda = Some(lsda_address);
+                    dwarf_frametable.add_fde(cie_id, fde);
+                }
+            }
 
-        #[cfg(feature = "unwind")]
-        let dwarf = 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 writer = WriterRelocate::new(target.triple().endianness().ok());
+            if let Some(lsda_section_index) = lsda_section_index {
+                for (func_idx, offset) in function_lsda_offsets.iter().enumerate() {
+                    if let Some(offset) = offset {
+                        writer.register_lsda_symbol(
+                            WriterRelocate::lsda_symbol(LocalFunctionIndex::new(func_idx)),
+                            RelocationTarget::CustomSection(lsda_section_index),
+                            *offset,
+                        );
+                    }
+                }
             }
-            let mut eh_frame = EhFrame(WriterRelocate::new(target.triple().endianness().ok()));
+
+            let mut eh_frame = EhFrame(writer);
             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));
         };
+
+        let module_hash = module.hash_string();
+
         #[cfg(not(feature = "unwind"))]
-        let dwarf = None;
+        let _ = fdes;
 
         // function call trampolines (only for local functions, by signature)
         #[cfg(not(feature = "rayon"))]
@@ -362,10 +424,23 @@ impl Compiler for CraneliftCompiler {
             .values()
             .collect::<Vec<_>>()
             .into_iter()
-            .map(|sig| make_trampoline_function_call(&*isa, &mut cx, sig))
+            .map(|sig| {
+                let trampoline = make_trampoline_function_call(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &mut cx,
+                    sig,
+                    &module_hash,
+                )?;
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+                Ok(trampoline)
+            })
             .collect::<Result<Vec<FunctionBody>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<SignatureIndex, FunctionBody>>();
+            .collect();
         #[cfg(feature = "rayon")]
         let function_call_trampolines = module
             .signatures
@@ -373,11 +448,22 @@ impl Compiler for CraneliftCompiler {
             .collect::<Vec<_>>()
             .par_iter()
             .map_init(FunctionBuilderContext::new, |cx, sig| {
-                make_trampoline_function_call(&*isa, cx, sig)
+                let trampoline = make_trampoline_function_call(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    cx,
+                    sig,
+                    &module_hash,
+                )?;
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+                Ok(trampoline)
             })
             .collect::<Result<Vec<FunctionBody>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<SignatureIndex, FunctionBody>>();
+            .collect();
 
         use wasmer_types::VMOffsets;
         let offsets = VMOffsets::new_for_trampolines(frontend_config.pointer_bytes());
@@ -389,56 +475,156 @@ impl Compiler for CraneliftCompiler {
             .imported_function_types()
             .collect::<Vec<_>>()
             .into_iter()
-            .map(|func_type| make_trampoline_dynamic_function(&*isa, &offsets, &mut cx, &func_type))
+            .map(|func_type| {
+                let trampoline = make_trampoline_dynamic_function(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &offsets,
+                    &mut cx,
+                    &func_type,
+                    &module_hash,
+                )?;
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+                Ok(trampoline)
+            })
             .collect::<Result<Vec<_>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+            .collect();
         #[cfg(feature = "rayon")]
         let dynamic_function_trampolines = module
             .imported_function_types()
             .collect::<Vec<_>>()
             .par_iter()
             .map_init(FunctionBuilderContext::new, |cx, func_type| {
-                make_trampoline_dynamic_function(&*isa, &offsets, cx, func_type)
+                let trampoline = make_trampoline_dynamic_function(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &offsets,
+                    cx,
+                    func_type,
+                    &module_hash,
+                )?;
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+                Ok(trampoline)
             })
             .collect::<Result<Vec<_>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+            .collect();
+
+        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<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
+    ) -> 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,
+                    progress_callback,
+                )
+            })
+        }
+
+        #[cfg(not(feature = "rayon"))]
+        {
+            self.compile_module_internal(
+                target,
+                compile_info,
+                module_translation_state,
+                function_body_inputs,
+                progress_callback,
+            )
+        }
+    }
+}
+
+fn mach_reloc_to_reloc(
+    module: &ModuleInfo,
+    func_index_map: &cranelift_entity::PrimaryMap<ir::UserExternalNameRef, ir::UserExternalName>,
+    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 {
+        let func_index = func_index_map[*extname_ref].index;
         //debug_assert_eq!(namespace, 0);
         RelocationTarget::LocalFunc(
             module
-                .local_func_index(FunctionIndex::from_u32(extname_ref.as_u32()))
+                .local_func_index(FunctionIndex::from_u32(func_index))
                 .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,
     }
 }
 
@@ -452,20 +638,31 @@ fn mach_trap_to_trap(trap: &MachTrap) -> TrapInformation {
 
 /// Translates the Cranelift IR TrapCode into generic Trap Code
 fn translate_ir_trapcode(trap: ir::TrapCode) -> TrapCode {
-    match trap {
-        ir::TrapCode::StackOverflow => TrapCode::StackOverflow,
-        ir::TrapCode::HeapOutOfBounds => TrapCode::HeapAccessOutOfBounds,
-        ir::TrapCode::HeapMisaligned => TrapCode::UnalignedAtomic,
-        ir::TrapCode::TableOutOfBounds => TrapCode::TableAccessOutOfBounds,
-        ir::TrapCode::IndirectCallToNull => TrapCode::IndirectCallToNull,
-        ir::TrapCode::BadSignature => TrapCode::BadSignature,
-        ir::TrapCode::IntegerOverflow => TrapCode::IntegerOverflow,
-        ir::TrapCode::IntegerDivisionByZero => TrapCode::IntegerDivisionByZero,
-        ir::TrapCode::BadConversionToInteger => TrapCode::BadConversionToInteger,
-        ir::TrapCode::UnreachableCodeReached => TrapCode::UnreachableCodeReached,
-        ir::TrapCode::Interrupt => unimplemented!("Interrupts 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),
+    if trap == ir::TrapCode::STACK_OVERFLOW {
+        TrapCode::StackOverflow
+    } else if trap == ir::TrapCode::HEAP_OUT_OF_BOUNDS {
+        TrapCode::HeapAccessOutOfBounds
+    } else if trap == crate::TRAP_HEAP_MISALIGNED {
+        TrapCode::UnalignedAtomic
+    } else if trap == crate::TRAP_TABLE_OUT_OF_BOUNDS {
+        TrapCode::TableAccessOutOfBounds
+    } else if trap == crate::TRAP_INDIRECT_CALL_TO_NULL {
+        TrapCode::IndirectCallToNull
+    } else if trap == crate::TRAP_BAD_SIGNATURE {
+        TrapCode::BadSignature
+    } else if trap == ir::TrapCode::INTEGER_OVERFLOW {
+        TrapCode::IntegerOverflow
+    } else if trap == ir::TrapCode::INTEGER_DIVISION_BY_ZERO {
+        TrapCode::IntegerDivisionByZero
+    } else if trap == ir::TrapCode::BAD_CONVERSION_TO_INTEGER {
+        TrapCode::BadConversionToInteger
+    } else if trap == crate::TRAP_UNREACHABLE {
+        TrapCode::UnreachableCodeReached
+    } else if trap == crate::TRAP_INTERRUPT {
+        unimplemented!("Interrupts not supported")
+    } else if trap == crate::TRAP_NULL_REFERENCE || trap == crate::TRAP_NULL_I31_REF {
+        unimplemented!("Null reference not supported")
+    } else {
+        unimplemented!("Trap code {trap:?} not supported")
     }
 }
diff --git a/lib/compiler-cranelift/src/config.rs b/lib/compiler-cranelift/src/config.rs
index 0ce14a4ceb..787ba9d7b4 100644
--- a/lib/compiler-cranelift/src/config.rs
+++ b/lib/compiler-cranelift/src/config.rs
@@ -1,10 +1,86 @@
 use crate::compiler::CraneliftCompiler;
-use cranelift_codegen::isa::{lookup, TargetIsa};
-use cranelift_codegen::settings::{self, Configurable};
-use cranelift_codegen::CodegenResult;
-use std::sync::Arc;
-use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{Architecture, CpuFeature, Target};
+use cranelift_codegen::{
+    CodegenResult,
+    isa::{TargetIsa, lookup},
+    settings::{self, Configurable},
+};
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{self, Write},
+    sync::Arc,
+};
+use std::{num::NonZero, path::PathBuf};
+use target_lexicon::OperatingSystem;
+use wasmer_compiler::{
+    Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware,
+    misc::{CompiledKind, function_kind_to_filename, save_assembly_to_file},
+};
+use wasmer_types::{
+    Features,
+    target::{Architecture, CpuFeature, Target},
+};
+
+/// Callbacks to the different Cranelift compilation phases.
+#[derive(Debug, Clone)]
+pub struct CraneliftCallbacks {
+    debug_dir: PathBuf,
+}
+
+impl CraneliftCallbacks {
+    /// Creates a new instance of `CraneliftCallbacks` with the specified debug directory.
+    pub fn new(debug_dir: PathBuf) -> Result<Self, io::Error> {
+        // Create the debug dir in case it doesn't exist
+        std::fs::create_dir_all(&debug_dir)?;
+        Ok(Self { debug_dir })
+    }
+
+    fn base_path(&self, module_hash: &Option<String>) -> PathBuf {
+        let mut path = self.debug_dir.clone();
+        if let Some(hash) = module_hash {
+            path.push(hash);
+        }
+        std::fs::create_dir_all(&path)
+            .unwrap_or_else(|_| panic!("cannot create debug directory: {}", path.display()));
+        path
+    }
+
+    /// Writes the pre-optimization intermediate representation to a debug file.
+    pub fn preopt_ir(&self, kind: &CompiledKind, module_hash: &Option<String>, mem_buffer: &[u8]) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".preopt.clif"));
+        let mut file =
+            File::create(path).expect("Error while creating debug file from Cranelift IR");
+        file.write_all(mem_buffer).unwrap();
+    }
+
+    /// Writes the object file memory buffer to a debug file.
+    pub fn obj_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        mem_buffer: &[u8],
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".o"));
+        let mut file =
+            File::create(path).expect("Error while creating debug file from Cranelift object");
+        file.write_all(mem_buffer).unwrap();
+    }
+
+    /// Writes the assembly memory buffer to a debug file.
+    pub fn asm_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        arch: Architecture,
+        mem_buffer: &[u8],
+    ) -> Result<(), wasmer_types::CompileError> {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".s"));
+        save_assembly_to_file(arch, path, mem_buffer, HashMap::<usize, String>::new())
+    }
+}
 
 // Runtime Environment
 
@@ -31,10 +107,14 @@ 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>>,
+    pub(crate) callbacks: Option<CraneliftCallbacks>,
 }
 
 impl Cranelift {
@@ -46,7 +126,10 @@ 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,
+            callbacks: None,
         }
     }
 
@@ -59,6 +142,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 +155,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
@@ -117,12 +206,11 @@ impl Cranelift {
             builder.enable("has_lzcnt").expect("should be valid flag");
         }
 
-        builder.finish(self.flags(target))
+        builder.finish(self.flags())
     }
 
     /// Generates the flags for the compiler
-    pub fn flags(&self, target: &Target) -> settings::Flags {
-        let is_riscv = matches!(target.triple().architecture, Architecture::Riscv64(_));
+    pub fn flags(&self) -> settings::Flags {
         let mut flags = settings::builder();
 
         // Enable probestack
@@ -130,17 +218,9 @@ impl Cranelift {
             .enable("enable_probestack")
             .expect("should be valid flag");
 
-        // Only inline probestack is supported on AArch64
-        if matches!(target.triple().architecture, Architecture::Aarch64(_)) {
-            flags
-                .set("probestack_strategy", "inline")
-                .expect("should be valid flag");
-        }
-
-        // There are two possible traps for division, and this way
-        // we get the proper one if code traps.
+        // Always use inline stack probes (otherwise the call to Probestack needs to be relocated).
         flags
-            .enable("avoid_div_traps")
+            .set("probestack_strategy", "inline")
             .expect("should be valid flag");
 
         if self.enable_pic {
@@ -153,17 +233,15 @@ impl Cranelift {
             .enable("use_colocated_libcalls")
             .expect("should be a valid flag");
 
-        // Invert cranelift's default-on verification to instead default off.
-        let enable_verifier = if self.enable_verifier {
-            "true"
-        } else {
-            "false"
-        };
+        // Allow Cranelift to implicitly spill multi-value returns via a hidden
+        // StructReturn argument when register results are exhausted.
         flags
-            .set("enable_verifier", enable_verifier)
-            .expect("should be valid flag");
+            .enable("enable_multi_ret_implicit_sret")
+            .expect("should be a valid flag");
+
+        // Invert cranelift's default-on verification to instead default off.
         flags
-            .set("enable_safepoints", "true")
+            .set("enable_verifier", &self.enable_verifier.to_string())
             .expect("should be valid flag");
 
         flags
@@ -177,27 +255,22 @@ 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 {
-            "false"
-        };
         flags
-            .set("enable_nan_canonicalization", enable_nan_canonicalization)
+            .set(
+                "enable_nan_canonicalization",
+                &self.enable_nan_canonicalization.to_string(),
+            )
             .expect("should be valid flag");
 
         settings::Flags::new(flags)
     }
+
+    /// Callbacks that will triggered in the different compilation
+    /// phases in Cranelift.
+    pub fn callbacks(&mut self, callbacks: Option<CraneliftCallbacks>) -> &mut Self {
+        self.callbacks = callbacks;
+        self
+    }
 }
 
 impl CompilerConfig for Cranelift {
@@ -209,6 +282,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;
     }
@@ -222,6 +299,14 @@ impl CompilerConfig for Cranelift {
     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();
+        if target.triple().operating_system == OperatingSystem::Linux {
+            feats.exceptions(true);
+        }
+        feats
+    }
 }
 
 impl Default for Cranelift {
diff --git a/lib/compiler-cranelift/src/debug/address_map.rs b/lib/compiler-cranelift/src/debug/address_map.rs
index c8900a0bc4..0adfaba2b5 100644
--- a/lib/compiler-cranelift/src/debug/address_map.rs
+++ b/lib/compiler-cranelift/src/debug/address_map.rs
@@ -2,8 +2,8 @@
 // addresses of a WebAssembly module into the native code.
 
 use cranelift_codegen::ir;
-use wasmer_types::entity::PrimaryMap;
 use wasmer_types::LocalFunctionIndex;
+use wasmer_types::entity::PrimaryMap;
 
 /// Value ranges for functions.
 pub type ValueLabelsRanges = PrimaryMap<LocalFunctionIndex, cranelift_codegen::ValueLabelsRanges>;
diff --git a/lib/compiler-cranelift/src/dwarf.rs b/lib/compiler-cranelift/src/dwarf.rs
index 8ab9b0b4b2..bf51f1ff2c 100644
--- a/lib/compiler-cranelift/src/dwarf.rs
+++ b/lib/compiler-cranelift/src/dwarf.rs
@@ -1,20 +1,24 @@
 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 gimli::{RunTimeEndian, SectionId, constants};
+use std::collections::HashMap;
+use wasmer_compiler::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody},
 };
+use wasmer_types::{LibCall, LocalFunctionIndex, entity::EntityRef, target::Endianness};
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {
     pub relocs: Vec<Relocation>,
     writer: EndianVec<RunTimeEndian>,
+    lsda_symbols: HashMap<usize, (RelocationTarget, u32)>,
 }
 
 impl WriterRelocate {
     pub const FUNCTION_SYMBOL: usize = 0;
+    pub const PERSONALITY_SYMBOL: usize = 1;
+    pub const LSDA_SYMBOL_BASE: usize = 2;
+
     pub fn new(endianness: Option<Endianness>) -> Self {
         let endianness = match endianness {
             Some(Endianness::Little) => RunTimeEndian::Little,
@@ -25,15 +29,25 @@ impl WriterRelocate {
         Self {
             relocs: Vec::new(),
             writer: EndianVec::new(endianness),
+            lsda_symbols: HashMap::new(),
         }
     }
 
+    pub fn register_lsda_symbol(&mut self, symbol: usize, target: RelocationTarget, offset: u32) {
+        self.lsda_symbols.insert(symbol, (target, offset));
+    }
+
+    pub fn lsda_symbol(func_index: LocalFunctionIndex) -> usize {
+        Self::LSDA_SYMBOL_BASE + func_index.index()
+    }
+
     pub fn into_section(mut self) -> CustomSection {
         // GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
         self.writer.write_u32(0).unwrap();
         let data = self.writer.into_vec();
         CustomSection {
             protection: CustomSectionProtection::Read,
+            alignment: None,
             bytes: SectionBody::new_with_vec(data),
             relocations: self.relocs,
         }
@@ -81,6 +95,40 @@ impl Writer for WriterRelocate {
                         addend,
                     });
                     self.write_udata(addend as _, size)
+                } else if symbol == Self::PERSONALITY_SYMBOL {
+                    let offset = self.len() as u32;
+                    let kind = match size {
+                        4 => RelocationKind::Abs4,
+                        8 => RelocationKind::Abs8,
+                        other => unimplemented!(
+                            "dwarf relocation size for personality not supported: {}",
+                            other
+                        ),
+                    };
+                    self.relocs.push(Relocation {
+                        kind,
+                        reloc_target: RelocationTarget::LibCall(LibCall::EHPersonality),
+                        offset,
+                        addend,
+                    });
+                    self.write_udata(0, size)
+                } else if let Some((target, base)) = self.lsda_symbols.get(&symbol) {
+                    let offset = self.len() as u32;
+                    let kind = match size {
+                        4 => RelocationKind::Abs4,
+                        8 => RelocationKind::Abs8,
+                        other => unimplemented!(
+                            "dwarf relocation size for LSDA not supported: {}",
+                            other
+                        ),
+                    };
+                    self.relocs.push(Relocation {
+                        kind,
+                        reloc_target: *target,
+                        offset,
+                        addend: *base as i64 + addend,
+                    });
+                    self.write_udata(0, size)
                 } else {
                     unreachable!("Symbol {} in DWARF not recognized", symbol);
                 }
@@ -88,6 +136,24 @@ impl Writer for WriterRelocate {
         }
     }
 
+    fn write_eh_pointer(
+        &mut self,
+        address: Address,
+        eh_pe: constants::DwEhPe,
+        size: u8,
+    ) -> Result<()> {
+        if eh_pe == constants::DW_EH_PE_absptr {
+            self.write_address(address, size)
+        } else {
+            match address {
+                Address::Constant(_) => self.writer.write_eh_pointer(address, eh_pe, size),
+                Address::Symbol { .. } => {
+                    unimplemented!("eh pointer encoding {eh_pe:?} not supported for symbol targets")
+                }
+            }
+        }
+    }
+
     fn write_offset(&mut self, _val: usize, _section: SectionId, _size: u8) -> Result<()> {
         unimplemented!("write_offset not yet implemented");
     }
diff --git a/lib/compiler-cranelift/src/eh.rs b/lib/compiler-cranelift/src/eh.rs
new file mode 100644
index 0000000000..a1108514cb
--- /dev/null
+++ b/lib/compiler-cranelift/src/eh.rs
@@ -0,0 +1,452 @@
+//! Helpers for generating DWARF LSDA data for Cranelift-compiled functions.
+//!
+//! The structures and encoding implemented here mirror what LLVM produces for
+//! Wasm exception handling so that Wasmer's libunwind personalities can parse
+//! the tables without any runtime changes.
+
+use cranelift_codegen::{
+    ExceptionContextLoc, FinalizedMachCallSite, FinalizedMachExceptionHandler,
+};
+use cranelift_entity::EntityRef;
+use itertools::Itertools;
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::convert::TryFrom;
+use std::io::{Cursor, Write};
+
+use wasmer_compiler::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
+};
+
+/// Relocation information for an LSDA entry that references a tag constant.
+#[derive(Debug, Clone)]
+pub struct TagRelocation {
+    /// Offset within the LSDA blob where the relocation should be applied.
+    pub offset: u32,
+    /// The module-local exception tag value.
+    pub tag: u32,
+}
+
+/// Fully encoded LSDA bytes for a single function, together with pending tag
+/// relocations that will be resolved once the global tag section is built.
+#[derive(Debug, Clone)]
+pub struct FunctionLsdaData {
+    pub bytes: Vec<u8>,
+    pub relocations: Vec<TagRelocation>,
+}
+
+/// Build the LSDA for a single function given the finalized Cranelift
+/// call-site metadata.
+pub fn build_function_lsda<'a>(
+    call_sites: impl Iterator<Item = FinalizedMachCallSite<'a>>,
+    function_length: usize,
+    pointer_bytes: u8,
+) -> Option<FunctionLsdaData> {
+    let mut sites = Vec::new();
+
+    for site in call_sites {
+        let mut catches = Vec::new();
+        let mut landing_pad = None;
+
+        // Our landing pads handle all the tags considered for a call instruction, thus
+        // we use the latest landing pad.
+        for handler in site.exception_handlers {
+            match handler {
+                FinalizedMachExceptionHandler::Tag(tag, offset) => {
+                    landing_pad = Some(landing_pad.unwrap_or(*offset));
+                    catches.push(ExceptionType::Tag {
+                        tag: u32::try_from(tag.index()).expect("tag index fits in u32"),
+                    });
+                }
+                FinalizedMachExceptionHandler::Default(offset) => {
+                    landing_pad = Some(landing_pad.unwrap_or(*offset));
+                    catches.push(ExceptionType::CatchAll);
+                }
+                FinalizedMachExceptionHandler::Context(context) => {
+                    // Context records are used by Cranelift to thread VMContext
+                    // information through the landing pad. We emit the LSDA
+                    // regardless of whether we see them; nothing to do here.
+                    match context {
+                        ExceptionContextLoc::SPOffset(_) | ExceptionContextLoc::GPR(_) => {}
+                    }
+                }
+            }
+        }
+
+        if catches.is_empty() {
+            continue;
+        }
+
+        let landing_pad = landing_pad.expect("landing pad offset set when catches exist");
+        let cs_start = site.ret_addr.saturating_sub(1);
+
+        sites.push(CallSiteDesc {
+            start: cs_start,
+            len: 1,
+            landing_pad,
+            actions: catches,
+        });
+    }
+
+    if sites.is_empty() {
+        return None;
+    }
+
+    // Ensure all instructions in the function are covered by filling gaps with
+    // default unwinding behavior (no catch actions).
+    let mut current_pos = 0u32;
+    let mut filled_sites = Vec::new();
+
+    for site in sites {
+        if site.start > current_pos {
+            // Gap found: add a default site that covers instructions with no handlers
+            filled_sites.push(CallSiteDesc {
+                start: current_pos,
+                len: site.start - current_pos,
+                landing_pad: 0,
+                actions: Vec::new(),
+            });
+        }
+        current_pos = site.start + site.len;
+        filled_sites.push(site);
+    }
+
+    // Cover any remaining instructions at the end of the function
+    if current_pos < function_length as u32 {
+        filled_sites.push(CallSiteDesc {
+            start: current_pos,
+            len: function_length as u32 - current_pos,
+            landing_pad: 0,
+            actions: Vec::new(),
+        });
+    }
+
+    let sites = filled_sites;
+
+    let mut type_entries = TypeTable::new();
+    let mut callsite_actions = Vec::with_capacity(sites.len());
+
+    for site in &sites {
+        #[cfg(debug_assertions)]
+        {
+            // CatchAll must always be the last item in the action list; otherwise, the tags that follow
+            // it will be ignored.
+            let catch_all_positions = site
+                .actions
+                .iter()
+                .positions(|a| matches!(a, ExceptionType::CatchAll))
+                .collect_vec();
+            assert!(catch_all_positions.iter().at_most_one().is_ok());
+            if let Some(&i) = catch_all_positions.first() {
+                assert!(i == site.actions.len() - 1);
+            }
+        }
+
+        let action_indices = site
+            .actions
+            .iter()
+            // Reverse actions to ensure CatchAll is always last in the chain, since the action table
+            // encoding uses back references and relies on this ordering.
+            .rev()
+            .map(|action| type_entries.get_or_insert(*action) as i32)
+            .collect_vec();
+        callsite_actions.push(action_indices);
+    }
+
+    let action_table = encode_action_table(&callsite_actions);
+    let call_site_table = encode_call_site_table(&sites, &action_table);
+    let (type_table_bytes, type_table_relocs) = type_entries.encode(pointer_bytes);
+
+    let call_site_table_len = call_site_table.len() as u64;
+    let mut writer = Cursor::new(Vec::new());
+    writer
+        .write_all(&gimli::DW_EH_PE_omit.0.to_le_bytes())
+        .unwrap(); // lpstart encoding omitted (relative to function start)
+
+    if type_entries.is_empty() {
+        writer
+            .write_all(&gimli::DW_EH_PE_omit.0.to_le_bytes())
+            .unwrap();
+    } else {
+        writer
+            .write_all(&gimli::DW_EH_PE_absptr.0.to_le_bytes())
+            .unwrap();
+    }
+
+    if !type_entries.is_empty() {
+        let ttype_table_end = 1 // call-site encoding byte
+            + uleb128_len(call_site_table_len)
+            + call_site_table.len()
+            + action_table.bytes.len()
+            + type_table_bytes.len();
+        leb128::write::unsigned(&mut writer, ttype_table_end as u64).unwrap();
+    }
+
+    writer
+        .write_all(&gimli::DW_EH_PE_udata4.0.to_le_bytes())
+        .unwrap();
+    leb128::write::unsigned(&mut writer, call_site_table_len).unwrap();
+    writer.write_all(&call_site_table).unwrap();
+    writer.write_all(&action_table.bytes).unwrap();
+
+    let type_table_offset = writer.position() as u32;
+    writer.write_all(&type_table_bytes).unwrap();
+
+    let mut relocations = Vec::new();
+    for reloc in type_table_relocs {
+        relocations.push(TagRelocation {
+            offset: type_table_offset + reloc.offset,
+            tag: reloc.tag,
+        });
+    }
+
+    Some(FunctionLsdaData {
+        bytes: writer.into_inner(),
+        relocations,
+    })
+}
+
+/// Build the global tag section and a tag->offset map.
+pub fn build_tag_section(
+    lsda_data: &[Option<FunctionLsdaData>],
+) -> Option<(CustomSection, HashMap<u32, u32>)> {
+    let mut unique_tags = HashSet::new();
+    for data in lsda_data.iter().flatten() {
+        for reloc in &data.relocations {
+            unique_tags.insert(reloc.tag);
+        }
+    }
+
+    if unique_tags.is_empty() {
+        return None;
+    }
+
+    let mut tags: Vec<u32> = unique_tags.into_iter().collect();
+    tags.sort_unstable();
+
+    let mut bytes = Vec::with_capacity(tags.len() * std::mem::size_of::<u32>());
+    let mut offsets = HashMap::new();
+    for tag in tags {
+        let offset = bytes.len() as u32;
+        bytes.extend_from_slice(&tag.to_ne_bytes());
+        offsets.insert(tag, offset);
+    }
+
+    let section = CustomSection {
+        protection: CustomSectionProtection::Read,
+        alignment: None,
+        bytes: SectionBody::new_with_vec(bytes),
+        relocations: Vec::new(),
+    };
+
+    Some((section, offsets))
+}
+
+/// Build the LSDA custom section and record the offset for each function.
+///
+/// Returns the section (if any) and a vector mapping each function index to
+/// its LSDA offset inside the section. Even when utilizing the same landing pad for exception tags,
+/// Cranelift generates separate landing pad locations.
+/// These locations are essentially small trampolines that redirect to the basic block we established (the EH dispatch block).
+///
+/// The section can be dumped using the elfutils' readelf tool:
+/// ```shell
+/// objcopy -I binary -O elf64-x86-64 --rename-section .data=.gcc_except_table,alloc,contents lsda.bin object.o && eu-readelf -w object.o
+/// ```
+pub fn build_lsda_section(
+    lsda_data: Vec<Option<FunctionLsdaData>>,
+    pointer_bytes: u8,
+    tag_offsets: &HashMap<u32, u32>,
+    tag_section_index: Option<SectionIndex>,
+) -> (Option<CustomSection>, Vec<Option<u32>>) {
+    let mut bytes = Vec::new();
+    let mut relocations = Vec::new();
+    let mut offsets_per_function = Vec::with_capacity(lsda_data.len());
+
+    let pointer_kind = match pointer_bytes {
+        4 => RelocationKind::Abs4,
+        8 => RelocationKind::Abs8,
+        other => panic!("unsupported pointer size {other} for LSDA generation"),
+    };
+
+    for data in lsda_data.into_iter() {
+        if let Some(data) = data {
+            let base = bytes.len() as u32;
+            bytes.extend_from_slice(&data.bytes);
+
+            for reloc in &data.relocations {
+                let target_offset = tag_offsets
+                    .get(&reloc.tag)
+                    .copied()
+                    .expect("missing tag offset for relocation");
+                relocations.push(Relocation {
+                    kind: pointer_kind,
+                    reloc_target: RelocationTarget::CustomSection(
+                        tag_section_index
+                            .expect("tag section index must exist when relocations are present"),
+                    ),
+                    offset: base + reloc.offset,
+                    addend: target_offset as i64,
+                });
+            }
+
+            offsets_per_function.push(Some(base));
+        } else {
+            offsets_per_function.push(None);
+        }
+    }
+
+    if bytes.is_empty() {
+        (None, offsets_per_function)
+    } else {
+        (
+            Some(CustomSection {
+                protection: CustomSectionProtection::Read,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(bytes),
+                relocations,
+            }),
+            offsets_per_function,
+        )
+    }
+}
+
+#[derive(Debug)]
+struct CallSiteDesc {
+    start: u32,
+    len: u32,
+    landing_pad: u32,
+    actions: Vec<ExceptionType>,
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+enum ExceptionType {
+    Tag { tag: u32 },
+    CatchAll,
+}
+
+#[derive(Debug)]
+struct TypeTable {
+    entries: indexmap::IndexSet<ExceptionType>,
+}
+
+impl TypeTable {
+    fn new() -> Self {
+        Self {
+            entries: indexmap::IndexSet::new(),
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    fn get_or_insert(&mut self, exception: ExceptionType) -> usize {
+        self.entries.insert(exception);
+
+        // The indices are one-based!
+        self.entries
+            .get_index_of(&exception)
+            .expect("must be already inserted")
+            + 1
+    }
+
+    fn encode(&self, pointer_bytes: u8) -> (Vec<u8>, Vec<TagRelocation>) {
+        let mut bytes = Vec::with_capacity(self.entries.len() * pointer_bytes as usize);
+        let mut relocations = Vec::new();
+
+        // Note the exception types must be streamed in the reverse order!
+        for entry in self.entries.iter().rev() {
+            let offset = bytes.len() as u32;
+            match entry {
+                ExceptionType::Tag { tag } => {
+                    bytes.extend(std::iter::repeat_n(0, pointer_bytes as usize));
+                    relocations.push(TagRelocation { offset, tag: *tag });
+                }
+                ExceptionType::CatchAll => {
+                    bytes.extend(std::iter::repeat_n(0, pointer_bytes as usize));
+                }
+            }
+        }
+
+        (bytes, relocations)
+    }
+}
+
+struct ActionTable {
+    bytes: Vec<u8>,
+    first_action_offsets: Vec<Option<u32>>,
+}
+
+fn encode_action_table(callsite_actions: &[Vec<i32>]) -> ActionTable {
+    let mut writer = Cursor::new(Vec::new());
+    let mut first_action_offsets = Vec::new();
+
+    let mut cache = HashMap::new();
+
+    for actions in callsite_actions {
+        if actions.is_empty() {
+            first_action_offsets.push(None);
+        } else {
+            match cache.entry(actions.clone()) {
+                Entry::Occupied(entry) => {
+                    first_action_offsets.push(Some(*entry.get()));
+                }
+                Entry::Vacant(entry) => {
+                    let mut last_action_start = 0;
+                    for (i, &ttype_index) in actions.iter().enumerate() {
+                        let next_action_start = writer.position();
+                        leb128::write::signed(&mut writer, ttype_index as i64)
+                            .expect("leb128 write failed");
+
+                        if i != 0 {
+                            // Make a linked list to the previous action
+                            let displacement = last_action_start - writer.position() as i64;
+                            leb128::write::signed(&mut writer, displacement)
+                                .expect("leb128 write failed");
+                        } else {
+                            leb128::write::signed(&mut writer, 0).expect("leb128 write failed");
+                        }
+                        last_action_start = next_action_start as i64;
+                    }
+                    let last_action_start = last_action_start as u32;
+                    entry.insert(last_action_start);
+                    first_action_offsets.push(Some(last_action_start));
+                }
+            }
+        }
+    }
+
+    ActionTable {
+        bytes: writer.into_inner(),
+        first_action_offsets,
+    }
+}
+
+fn encode_call_site_table(callsites: &[CallSiteDesc], action_table: &ActionTable) -> Vec<u8> {
+    let mut writer = Cursor::new(Vec::new());
+    for (idx, site) in callsites.iter().enumerate() {
+        write_encoded_offset(site.start, &mut writer);
+        write_encoded_offset(site.len, &mut writer);
+        write_encoded_offset(site.landing_pad, &mut writer);
+
+        let action = match action_table.first_action_offsets[idx] {
+            Some(offset) => offset as u64 + 1,
+            None => 0,
+        };
+        leb128::write::unsigned(&mut writer, action).expect("leb128 write failed");
+    }
+    writer.into_inner()
+}
+
+fn write_encoded_offset(val: u32, out: &mut impl Write) {
+    // We use DW_EH_PE_udata4 for all offsets.
+    out.write_all(&val.to_le_bytes())
+        .expect("write to buffer failed")
+}
+
+fn uleb128_len(value: u64) -> usize {
+    let mut cursor = Cursor::new([0u8; 10]);
+    leb128::write::unsigned(&mut cursor, value).unwrap()
+}
diff --git a/lib/compiler-cranelift/src/func_environ.rs b/lib/compiler-cranelift/src/func_environ.rs
index 1160e00f96..3ce8a93db7 100644
--- a/lib/compiler-cranelift/src/func_environ.rs
+++ b/lib/compiler-cranelift/src/func_environ.rs
@@ -1,40 +1,63 @@
 // 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::{
+    HashMap,
+    heap::{Heap, HeapData, HeapStyle},
+    table::{TableData, TableSize},
+    translator::{
+        EXN_REF_TYPE, FuncEnvironment as BaseFuncEnvironment, GlobalVariable, LandingPad, TAG_TYPE,
+        TargetEnvironment,
+    },
+};
+use cranelift_codegen::{
+    cursor::FuncCursor,
+    ir::{
+        self, AbiParam, ArgumentPurpose, BlockArg, Endianness, ExceptionTableData,
+        ExceptionTableItem, ExceptionTag, Function, InstBuilder, MemFlags, Signature,
+        UserExternalName,
+        condcodes::IntCC,
+        immediates::{Offset32, Uimm64},
+        types::*,
+    },
+    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 smallvec::SmallVec;
 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,
+    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, MemoryStyle,
+    ModuleInfo, SignatureIndex, TableIndex, TableStyle, TagIndex, Type as WasmerType,
+    VMBuiltinFunctionIndex, VMOffsets, WasmError, WasmResult,
+    entity::{EntityRef, PrimaryMap, SecondaryMap},
 };
-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 {
-    ir::ExternalName::user(ir::UserExternalNameRef::from_u32(func_index.as_u32()))
+pub fn get_function_name(func: &mut Function, func_index: FunctionIndex) -> ir::ExternalName {
+    ir::ExternalName::user(
+        func.params
+            .ensure_user_func_name(UserExternalName::new(0, func_index.as_u32())),
+    )
 }
 
 /// 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()
 }
 
+#[derive(Clone)]
+struct ExceptionFieldLayout {
+    offset: u32,
+    ty: ir::Type,
+}
+
+#[derive(Clone)]
+struct ExceptionTypeLayout {
+    fields: SmallVec<[ExceptionFieldLayout; 4]>,
+}
+
 /// The `FuncEnvironment` implementation for use by the `ModuleEnvironment`.
 pub struct FuncEnvironment<'module_environment> {
     /// Target-specified configuration.
@@ -49,6 +72,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>,
 
@@ -113,13 +139,25 @@ pub struct FuncEnvironment<'module_environment> {
     /// The external function signature for implementing wasm's `memory32.atomic.notify`.
     memory32_atomic_notify_sig: Option<ir::SigRef>,
 
+    /// Cached signatures for exception helper builtins.
+    personality2_sig: Option<ir::SigRef>,
+    throw_sig: Option<ir::SigRef>,
+    alloc_exception_sig: Option<ir::SigRef>,
+    read_exception_sig: Option<ir::SigRef>,
+    read_exnref_sig: Option<ir::SigRef>,
+
+    /// Cached payload layouts for exception tags.
+    exception_type_layouts: HashMap<u32, ExceptionTypeLayout>,
+
     /// Offsets to struct fields accessed by JIT code.
     offsets: VMOffsets,
 
     /// 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 +174,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,
@@ -155,8 +194,15 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             memory32_atomic_wait32_sig: None,
             memory32_atomic_wait64_sig: None,
             memory32_atomic_notify_sig: None,
+            personality2_sig: None,
+            throw_sig: None,
+            alloc_exception_sig: None,
+            read_exception_sig: None,
+            read_exnref_sig: None,
+            exception_type_layouts: HashMap::new(),
             offsets: VMOffsets::new(target_config.pointer_bytes(), module),
             memory_styles,
+            tables: Default::default(),
             table_styles,
         }
     }
@@ -165,6 +211,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);
@@ -183,7 +303,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     // dst
                     AbiParam::new(I32),
                     // value
-                    AbiParam::new(R64),
+                    AbiParam::new(self.reference_type()),
                     // len
                     AbiParam::new(I32),
                 ],
@@ -214,7 +334,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
                     AbiParam::new(I32),
                 ],
-                returns: vec![AbiParam::new(R64)],
+                returns: vec![AbiParam::new(self.reference_type())],
                 call_conv: self.target_config.default_call_conv,
             })
         });
@@ -242,7 +362,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     AbiParam::new(I32),
                     AbiParam::new(I32),
                 ],
-                returns: vec![AbiParam::new(R64)],
+                returns: vec![AbiParam::new(self.reference_type())],
                 call_conv: self.target_config.default_call_conv,
             })
         });
@@ -277,7 +397,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
                     AbiParam::new(I32),
                     AbiParam::new(I32),
-                    AbiParam::new(R64),
+                    AbiParam::new(self.reference_type()),
                 ],
                 returns: vec![],
                 call_conv: self.target_config.default_call_conv,
@@ -313,7 +433,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                 params: vec![
                     AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
                     // TODO: figure out what the representation of a Wasm value is
-                    AbiParam::new(R64),
+                    AbiParam::new(self.reference_type()),
                     AbiParam::new(I32),
                     AbiParam::new(I32),
                 ],
@@ -829,6 +949,287 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
+    fn get_personality2_func(
+        &mut self,
+        func: &mut Function,
+    ) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.personality2_sig.unwrap_or_else(|| {
+            let mut signature = Signature::new(self.target_config.default_call_conv);
+            signature.params.push(AbiParam::new(self.pointer_type()));
+            signature.params.push(AbiParam::new(self.pointer_type()));
+            signature.returns.push(AbiParam::new(TAG_TYPE));
+            let sig = func.import_signature(signature);
+            self.personality2_sig = Some(sig);
+            sig
+        });
+        (
+            sig,
+            VMBuiltinFunctionIndex::get_imported_personality2_index(),
+        )
+    }
+
+    fn get_throw_func(&mut self, func: &mut Function) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.throw_sig.unwrap_or_else(|| {
+            let mut signature = Signature::new(self.target_config.default_call_conv);
+            signature.params.push(AbiParam::special(
+                self.pointer_type(),
+                ArgumentPurpose::VMContext,
+            ));
+            signature.params.push(AbiParam::new(EXN_REF_TYPE));
+            let sig = func.import_signature(signature);
+            self.throw_sig = Some(sig);
+            sig
+        });
+        (sig, VMBuiltinFunctionIndex::get_imported_throw_index())
+    }
+
+    fn get_alloc_exception_func(
+        &mut self,
+        func: &mut Function,
+    ) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.alloc_exception_sig.unwrap_or_else(|| {
+            let mut signature = Signature::new(self.target_config.default_call_conv);
+            signature.params.push(AbiParam::special(
+                self.pointer_type(),
+                ArgumentPurpose::VMContext,
+            ));
+            signature.params.push(AbiParam::new(TAG_TYPE));
+            signature.returns.push(AbiParam::new(EXN_REF_TYPE));
+            let sig = func.import_signature(signature);
+            self.alloc_exception_sig = Some(sig);
+            sig
+        });
+        (
+            sig,
+            VMBuiltinFunctionIndex::get_imported_alloc_exception_index(),
+        )
+    }
+
+    fn get_read_exnref_func(
+        &mut self,
+        func: &mut Function,
+    ) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.read_exnref_sig.unwrap_or_else(|| {
+            let mut signature = Signature::new(self.target_config.default_call_conv);
+            signature.params.push(AbiParam::special(
+                self.pointer_type(),
+                ArgumentPurpose::VMContext,
+            ));
+            signature.params.push(AbiParam::new(EXN_REF_TYPE));
+            signature.returns.push(AbiParam::new(self.pointer_type()));
+            let sig = func.import_signature(signature);
+            self.read_exnref_sig = Some(sig);
+            sig
+        });
+        (
+            sig,
+            VMBuiltinFunctionIndex::get_imported_read_exnref_index(),
+        )
+    }
+
+    fn get_read_exception_func(
+        &mut self,
+        func: &mut Function,
+    ) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.read_exception_sig.unwrap_or_else(|| {
+            let mut signature = Signature::new(self.target_config.default_call_conv);
+            signature.params.push(AbiParam::new(self.pointer_type()));
+            signature.returns.push(AbiParam::new(EXN_REF_TYPE));
+            let sig = func.import_signature(signature);
+            self.read_exception_sig = Some(sig);
+            sig
+        });
+        (
+            sig,
+            VMBuiltinFunctionIndex::get_imported_exception_into_exnref_index(),
+        )
+    }
+
+    fn exception_type_layout(&mut self, tag_index: TagIndex) -> WasmResult<&ExceptionTypeLayout> {
+        let key = tag_index.as_u32();
+        if !self.exception_type_layouts.contains_key(&key) {
+            let layout = self.compute_exception_type_layout(tag_index)?;
+            self.exception_type_layouts.insert(key, layout);
+        }
+        Ok(self.exception_type_layouts.get(&key).unwrap())
+    }
+
+    fn compute_exception_type_layout(
+        &self,
+        tag_index: TagIndex,
+    ) -> WasmResult<ExceptionTypeLayout> {
+        let sig_index = self.module.tags[tag_index];
+        let func_type = &self.module.signatures[sig_index];
+        let mut offset = 0u32;
+        let mut max_align = 1u32;
+        let mut fields = SmallVec::<[ExceptionFieldLayout; 4]>::new();
+
+        for wasm_ty in func_type.params() {
+            let ir_ty = self.map_wasmer_type_to_ir(*wasm_ty)?;
+            let field_size = ir_ty.bytes();
+            let align = field_size.max(1);
+            max_align = max_align.max(align);
+            offset = offset.next_multiple_of(align);
+            fields.push(ExceptionFieldLayout { offset, ty: ir_ty });
+            offset = offset
+                .checked_add(field_size)
+                .ok_or_else(|| WasmError::Unsupported("exception payload too large".to_string()))?;
+        }
+
+        Ok(ExceptionTypeLayout { fields })
+    }
+
+    fn map_wasmer_type_to_ir(&self, ty: WasmerType) -> WasmResult<ir::Type> {
+        Ok(match 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()
+            }
+        })
+    }
+
+    fn call_with_handlers(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        callee: ir::FuncRef,
+        args: &[ir::Value],
+        context: Option<ir::Value>,
+        landing_pad: Option<LandingPad>,
+        unreachable_on_return: bool,
+    ) -> SmallVec<[ir::Value; 4]> {
+        let sig_ref = builder.func.dfg.ext_funcs[callee].signature;
+        let return_types: SmallVec<[ir::Type; 4]> = builder.func.dfg.signatures[sig_ref]
+            .returns
+            .iter()
+            .map(|ret| ret.value_type)
+            .collect();
+
+        if landing_pad.is_none() {
+            let inst = builder.ins().call(callee, args);
+            let results: SmallVec<[ir::Value; 4]> =
+                builder.inst_results(inst).iter().copied().collect();
+            if unreachable_on_return {
+                builder.ins().trap(crate::TRAP_UNREACHABLE);
+            }
+            return results;
+        }
+
+        let continuation = builder.create_block();
+        let mut normal_args = SmallVec::<[BlockArg; 4]>::with_capacity(return_types.len());
+        let mut result_values = SmallVec::<[ir::Value; 4]>::with_capacity(return_types.len());
+        for (i, ty) in return_types.iter().enumerate() {
+            let val = builder.append_block_param(continuation, *ty);
+            result_values.push(val);
+            normal_args.push(BlockArg::TryCallRet(u32::try_from(i).unwrap()));
+        }
+        let continuation_call = builder
+            .func
+            .dfg
+            .block_call(continuation, normal_args.iter());
+
+        let mut table_items = Vec::new();
+        if let Some(ctx) = context {
+            table_items.push(ExceptionTableItem::Context(ctx));
+        }
+        if let Some(landing_pad) = landing_pad {
+            for tag in landing_pad.clauses {
+                let block_call = builder.func.dfg.block_call(
+                    landing_pad.block,
+                    &[BlockArg::TryCallExn(0), BlockArg::TryCallExn(1)],
+                );
+                table_items.push(match tag.wasm_tag {
+                    Some(tag) => ExceptionTableItem::Tag(ExceptionTag::from_u32(tag), block_call),
+                    None => ExceptionTableItem::Default(block_call),
+                });
+            }
+        }
+        let etd = ExceptionTableData::new(sig_ref, continuation_call, table_items);
+        let et = builder.func.dfg.exception_tables.push(etd);
+        builder.ins().try_call(callee, args, et);
+        builder.switch_to_block(continuation);
+        builder.seal_block(continuation);
+        if unreachable_on_return {
+            builder.ins().trap(crate::TRAP_UNREACHABLE);
+        }
+        result_values
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn call_indirect_with_handlers(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        sig: ir::SigRef,
+        func_addr: ir::Value,
+        args: &[ir::Value],
+        context: Option<ir::Value>,
+        landing_pad: Option<LandingPad>,
+        unreachable_on_return: bool,
+    ) -> SmallVec<[ir::Value; 4]> {
+        let return_types: SmallVec<[ir::Type; 4]> = builder.func.dfg.signatures[sig]
+            .returns
+            .iter()
+            .map(|ret| ret.value_type)
+            .collect();
+
+        if landing_pad.is_none() {
+            let inst = builder.ins().call_indirect(sig, func_addr, args);
+            let results: SmallVec<[ir::Value; 4]> =
+                builder.inst_results(inst).iter().copied().collect();
+            if unreachable_on_return {
+                builder.ins().trap(crate::TRAP_UNREACHABLE);
+            }
+            return results;
+        }
+
+        let continuation = builder.create_block();
+        let current_block = builder.current_block().expect("current block");
+        builder.insert_block_after(continuation, current_block);
+
+        let mut normal_args = SmallVec::<[BlockArg; 4]>::with_capacity(return_types.len());
+        let mut result_values = SmallVec::<[ir::Value; 4]>::with_capacity(return_types.len());
+        for (i, ty) in return_types.iter().enumerate() {
+            let val = builder.append_block_param(continuation, *ty);
+            result_values.push(val);
+            normal_args.push(BlockArg::TryCallRet(u32::try_from(i).unwrap()));
+        }
+        let continuation_call = builder
+            .func
+            .dfg
+            .block_call(continuation, normal_args.iter());
+
+        let mut table_items = Vec::new();
+        if let Some(ctx) = context {
+            table_items.push(ExceptionTableItem::Context(ctx));
+        }
+        if let Some(landing_pad) = landing_pad {
+            for tag in landing_pad.clauses {
+                let block_call = builder.func.dfg.block_call(
+                    landing_pad.block,
+                    &[BlockArg::TryCallExn(0), BlockArg::TryCallExn(1)],
+                );
+                table_items.push(match tag.wasm_tag {
+                    Some(tag) => ExceptionTableItem::Tag(ExceptionTag::from_u32(tag), block_call),
+                    None => ExceptionTableItem::Default(block_call),
+                });
+            }
+        }
+
+        let etd = ExceptionTableData::new(sig, continuation_call, table_items);
+        let et = builder.func.dfg.exception_tables.push(etd);
+        builder.ins().try_call_indirect(func_addr, args, et);
+        builder.switch_to_block(continuation);
+        builder.seal_block(continuation);
+        if unreachable_on_return {
+            builder.ins().trap(crate::TRAP_UNREACHABLE);
+        }
+
+        result_values
+    }
+
     /// Translates load of builtin function and returns a pair of values `vmctx`
     /// and address of the loaded function.
     fn translate_load_builtin_function_address(
@@ -851,83 +1252,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 +1308,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 +1326,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 +1348,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,13 +1368,33 @@ 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
+                | wasmer_compiler::wasmparser::AbstractHeapType::Extern
+                | wasmer_compiler::wasmparser::AbstractHeapType::Exn => pos.ins().iconst(
+                    if matches!(ty, wasmer_compiler::wasmparser::AbstractHeapType::Exn) {
+                        I32
+                    } else {
+                        self.reference_type()
+                    },
+                    0,
+                ),
+                _ => {
+                    return Err(WasmError::Unsupported(format!(
+                        "`ref.null T` that is not a `funcref`, an `externref` or an `exn`: {ty:?}"
+                    )));
+                }
+            },
+            HeapType::Concrete(_) => {
                 return Err(WasmError::Unsupported(
                     "`ref.null T` that is not a `funcref` or an `externref`".into(),
                 ));
             }
+            HeapType::Exact(_) => {
+                return Err(WasmError::Unsupported(
+                    "custom-descriptors not supported yet".into(),
+                ));
+            }
         })
     }
 
@@ -1017,17 +1403,9 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         mut pos: cranelift_codegen::cursor::FuncCursor,
         value: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let bool_is_null = match pos.func.dfg.value_type(value) {
-            // `externref`
-            ty if ty.is_ref() => pos.ins().is_null(value),
-            // `funcref`
-            ty if ty == self.pointer_type() => {
-                pos.ins()
-                    .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::Equal, value, 0)
-            }
-            _ => unreachable!(),
-        };
-
+        let bool_is_null =
+            pos.ins()
+                .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::Equal, value, 0);
         Ok(pos.ins().uextend(ir::types::I32, bool_is_null))
     }
 
@@ -1036,14 +1414,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 +1442,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 +1462,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 +1479,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 +1494,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 +1505,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 +1532,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 +1552,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()
+                }
+            },
         })
     }
 
@@ -1192,45 +1580,43 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
     ) -> WasmResult<ir::FuncRef> {
         let sigidx = self.module.functions[index];
         let signature = func.import_signature(self.signatures[sigidx].clone());
-        let name = get_function_name(index);
+        let name = get_function_name(func, index);
+
         Ok(func.import_function(ir::ExtFuncData {
             name,
             signature,
             colocated: true,
+            patchable: false,
         }))
     }
 
     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,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>> {
         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, crate::TRAP_INDIRECT_CALL_TO_NULL);
 
-        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 +1625,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, crate::TRAP_BAD_SIGNATURE);
             }
         }
 
         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,22 +1666,35 @@ 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))
+        let results = self.call_indirect_with_handlers(
+            builder,
+            sig_ref,
+            func_addr,
+            &real_call_args,
+            Some(vmctx),
+            landing_pad,
+            false,
+        );
+        Ok(results)
     }
 
     fn translate_call(
         &mut self,
-        mut pos: FuncCursor<'_>,
+        builder: &mut FunctionBuilder,
         callee_index: FunctionIndex,
         callee: ir::FuncRef,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>> {
         let mut real_call_args = Vec::with_capacity(call_args.len() + 2);
 
         // 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 +1702,248 @@ 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));
+            let results = self.call_with_handlers(
+                builder,
+                callee,
+                &real_call_args,
+                Some(caller_vmctx),
+                landing_pad,
+                false,
+            );
+            return Ok(results);
         }
 
         // 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))
+        let results = self.call_indirect_with_handlers(
+            builder,
+            sig_ref,
+            func_addr,
+            &real_call_args,
+            Some(vmctx),
+            landing_pad,
+            false,
+        );
+        Ok(results)
+    }
+
+    fn tag_param_arity(&self, tag_index: TagIndex) -> usize {
+        let sig_index = self.module.tags[tag_index];
+        let signature = &self.module.signatures[sig_index];
+        signature.params().len()
+    }
+
+    fn translate_exn_pointer_to_ref(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exn_ptr: ir::Value,
+    ) -> ir::Value {
+        let (read_sig, read_idx) = self.get_read_exception_func(builder.func);
+        let mut pos = builder.cursor();
+        let (_, read_addr) = self.translate_load_builtin_function_address(&mut pos, read_idx);
+        let read_call = builder.ins().call_indirect(read_sig, read_addr, &[exn_ptr]);
+        builder.inst_results(read_call)[0]
+    }
+
+    fn translate_exn_unbox(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        tag_index: TagIndex,
+        exnref: ir::Value,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>> {
+        let layout = self.exception_type_layout(tag_index)?.clone();
+
+        let (read_exnref_sig, read_exnref_idx) = self.get_read_exnref_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx, read_exnref_addr) =
+            self.translate_load_builtin_function_address(&mut pos, read_exnref_idx);
+        let read_exnref_call =
+            builder
+                .ins()
+                .call_indirect(read_exnref_sig, read_exnref_addr, &[vmctx, exnref]);
+        let payload_ptr = builder.inst_results(read_exnref_call)[0];
+
+        let mut values = SmallVec::<[ir::Value; 4]>::with_capacity(layout.fields.len());
+        let data_flags = ir::MemFlags::trusted();
+        for field in &layout.fields {
+            let value = builder.ins().load(
+                field.ty,
+                data_flags,
+                payload_ptr,
+                Offset32::new(field.offset as i32),
+            );
+            values.push(value);
+        }
+
+        Ok(values)
+    }
+
+    fn translate_exn_throw(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        tag_index: TagIndex,
+        args: &[ir::Value],
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<()> {
+        let layout = self.exception_type_layout(tag_index)?.clone();
+        if layout.fields.len() != args.len() {
+            return Err(WasmError::Generic(format!(
+                "exception payload arity mismatch: expected {}, got {}",
+                layout.fields.len(),
+                args.len()
+            )));
+        }
+
+        let (alloc_sig, alloc_idx) = self.get_alloc_exception_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx, alloc_addr) = self.translate_load_builtin_function_address(&mut pos, alloc_idx);
+        let tag_value = builder
+            .ins()
+            .iconst(TAG_TYPE, i64::from(tag_index.as_u32()));
+        let alloc_call = builder
+            .ins()
+            .call_indirect(alloc_sig, alloc_addr, &[vmctx, tag_value]);
+        let exnref = builder.inst_results(alloc_call)[0];
+
+        let (read_exnref_sig, read_exnref_idx) = self.get_read_exnref_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx, read_exnref_addr) =
+            self.translate_load_builtin_function_address(&mut pos, read_exnref_idx);
+        let read_exnref_call =
+            builder
+                .ins()
+                .call_indirect(read_exnref_sig, read_exnref_addr, &[vmctx, exnref]);
+        let payload_ptr = builder.inst_results(read_exnref_call)[0];
+
+        let store_flags = ir::MemFlags::trusted();
+        for (field, value) in layout.fields.iter().zip(args.iter()) {
+            debug_assert_eq!(
+                builder.func.dfg.value_type(*value),
+                field.ty,
+                "exception payload type mismatch"
+            );
+            builder.ins().store(
+                store_flags,
+                *value,
+                payload_ptr,
+                Offset32::new(field.offset as i32),
+            );
+        }
+
+        let (throw_sig, throw_idx) = self.get_throw_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx_value, throw_addr) =
+            self.translate_load_builtin_function_address(&mut pos, throw_idx);
+        let call_args = [vmctx_value, exnref];
+
+        let _ = self.call_indirect_with_handlers(
+            builder,
+            throw_sig,
+            throw_addr,
+            &call_args,
+            Some(vmctx_value),
+            landing_pad,
+            true,
+        );
+
+        Ok(())
+    }
+
+    fn translate_exn_throw_ref(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exnref: ir::Value,
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<()> {
+        let (throw_sig, throw_idx) = self.get_throw_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx_value, throw_addr) =
+            self.translate_load_builtin_function_address(&mut pos, throw_idx);
+        let call_args = [vmctx_value, exnref];
+
+        let _ = self.call_indirect_with_handlers(
+            builder,
+            throw_sig,
+            throw_addr,
+            &call_args,
+            Some(vmctx_value),
+            landing_pad,
+            true,
+        );
+
+        Ok(())
+    }
+
+    fn translate_exn_personality_selector(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exn_ptr: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let (sig, idx) = self.get_personality2_func(builder.func);
+        let pointer_type = self.pointer_type();
+        let exn_ty = builder.func.dfg.value_type(exn_ptr);
+        let exn_arg = if exn_ty == pointer_type {
+            exn_ptr
+        } else {
+            let mut flags = MemFlags::new();
+            flags.set_endianness(Endianness::Little);
+            builder.ins().bitcast(pointer_type, flags, exn_ptr)
+        };
+
+        let mut pos = builder.cursor();
+        let (vmctx_value, func_addr) = self.translate_load_builtin_function_address(&mut pos, idx);
+        let call = builder
+            .ins()
+            .call_indirect(sig, func_addr, &[vmctx_value, exn_arg]);
+        Ok(builder.inst_results(call)[0])
+    }
+
+    fn translate_exn_reraise_unmatched(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exnref: ir::Value,
+    ) -> WasmResult<()> {
+        let (throw_sig, throw_idx) = self.get_throw_func(builder.func);
+        let mut pos = builder.cursor();
+        let (vmctx_value, throw_addr) =
+            self.translate_load_builtin_function_address(&mut pos, throw_idx);
+        builder
+            .ins()
+            .call_indirect(throw_sig, throw_addr, &[vmctx_value, exnref]);
+        builder.ins().trap(crate::TRAP_UNREACHABLE);
+        Ok(())
     }
 
     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 +1959,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 +1974,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 +1997,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 +2021,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 +2056,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 +2071,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 +2107,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 +2145,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 +2169,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 +2215,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..b3035f9e74 100644
--- a/lib/compiler-cranelift/src/lib.rs
+++ b/lib/compiler-cranelift/src/lib.rs
@@ -6,7 +6,7 @@
 //! Compared to LLVM, Cranelift is a bit faster and made entirely in Rust.
 #![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
 #![warn(unused_import_braces)]
-#![allow(clippy::new_without_default, clippy::new_without_default)]
+#![allow(clippy::new_without_default)]
 #![warn(
     clippy::float_arithmetic,
     clippy::mut_mut,
@@ -16,7 +16,7 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(not(feature = "std"))]
 #[macro_use]
@@ -27,15 +27,13 @@ extern crate std;
 
 #[cfg(not(feature = "std"))]
 use hashbrown::{
-    hash_map,
+    HashMap, hash_map,
     hash_map::Entry::{Occupied, Vacant},
-    HashMap,
 };
 #[cfg(feature = "std")]
 use std::collections::{
-    hash_map,
+    HashMap, hash_map,
     hash_map::Entry::{Occupied, Vacant},
-    HashMap,
 };
 
 mod address_map;
@@ -44,14 +42,42 @@ mod config;
 mod debug;
 #[cfg(feature = "unwind")]
 mod dwarf;
+#[cfg(feature = "unwind")]
+mod eh;
 mod func_environ;
+mod heap;
+mod table;
 mod trampoline;
 mod translator;
 
+use cranelift_codegen::ir::TrapCode;
+
 pub use crate::compiler::CraneliftCompiler;
-pub use crate::config::{Cranelift, CraneliftOptLevel};
+pub use crate::config::{Cranelift, CraneliftCallbacks, CraneliftOptLevel};
 pub use crate::debug::{ModuleInfoMemoryOffset, ModuleInfoVmctxInfo, ValueLabelsRanges};
 pub use crate::trampoline::make_trampoline_function_call;
 
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Offset applied to user-defined trap codes to avoid colliding with
+/// Cranelift-reserved values.
+const TRAP_USER_OFFSET: u8 = 32;
+
+/// Trap reported when an indirect call targets a null function reference.
+#[allow(clippy::identity_op, reason = "for clarity")]
+pub const TRAP_INDIRECT_CALL_TO_NULL: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 0);
+/// Trap reported when an indirect call signature does not match.
+pub const TRAP_BAD_SIGNATURE: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 1);
+/// Trap reported when a table access goes out of bounds.
+pub const TRAP_TABLE_OUT_OF_BOUNDS: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 2);
+/// Trap reported when a heap access violates alignment guarantees.
+pub const TRAP_HEAP_MISALIGNED: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 3);
+/// Trap reported when unreachable code is executed.
+pub const TRAP_UNREACHABLE: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 4);
+/// Trap reported when a null reference is observed.
+pub const TRAP_NULL_REFERENCE: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 5);
+/// Trap reported when a null i31 reference is observed.
+pub const TRAP_NULL_I31_REF: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 6);
+/// Trap reported for interrupts (not currently supported).
+pub const TRAP_INTERRUPT: TrapCode = TrapCode::unwrap_user(TRAP_USER_OFFSET + 7);
diff --git a/lib/compiler-cranelift/src/table.rs b/lib/compiler-cranelift/src/table.rs
new file mode 100644
index 0000000000..6136e132ce
--- /dev/null
+++ b/lib/compiler-cranelift/src/table.rs
@@ -0,0 +1,104 @@
+use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir::{self, InstBuilder, condcodes::IntCC, immediates::Imm64};
+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, crate::TRAP_TABLE_OUT_OF_BOUNDS);
+        }
+
+        // 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(crate::TRAP_TABLE_OUT_OF_BOUNDS)),
+            )
+        } 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..4691d98199 100644
--- a/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
+++ b/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
@@ -3,25 +3,30 @@
 
 //! 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 crate::{
+    CraneliftCallbacks,
+    translator::{compiled_function_unwind_info, signature_to_cranelift_ir},
+};
+use cranelift_codegen::{
+    Context,
+    ir::{self, Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, UserFuncName},
+    isa::TargetIsa,
 };
-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 target_lexicon::Architecture;
+use wasmer_compiler::{misc::CompiledKind, types::function::FunctionBody};
+use wasmer_types::{CompileError, FunctionType, VMOffsets};
 
 /// Create a trampoline for invoking a WebAssembly function.
 pub fn make_trampoline_dynamic_function(
+    callbacks: &Option<CraneliftCallbacks>,
     isa: &dyn TargetIsa,
+    arch: Architecture,
     offsets: &VMOffsets,
     fn_builder_ctx: &mut FunctionBuilderContext,
     func_type: &FunctionType,
+    module_hash: &Option<String>,
 ) -> Result<FunctionBody, CompileError> {
     let pointer_type = isa.pointer_type();
     let frontend_config = isa.frontend_config();
@@ -47,6 +52,7 @@ pub fn make_trampoline_dynamic_function(
     let ss = context.func.create_sized_stack_slot(StackSlotData::new(
         StackSlotKind::ExplicitSlot,
         values_vec_len,
+        0,
     ));
 
     {
@@ -103,10 +109,34 @@ pub fn make_trampoline_dynamic_function(
         builder.finalize()
     }
 
+    if let Some(callbacks) = callbacks.as_ref() {
+        callbacks.preopt_ir(
+            &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+            module_hash,
+            context.func.display().to_string().as_bytes(),
+        );
+    }
+
     let mut code_buf = Vec::new();
-    context
-        .compile_and_emit(isa, &mut code_buf)
+    let mut ctrl_plane = Default::default();
+    let compiled = context
+        .compile(isa, &mut ctrl_plane)
         .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+    code_buf.extend_from_slice(compiled.code_buffer());
+
+    if let Some(callbacks) = callbacks.as_ref() {
+        callbacks.obj_memory_buffer(
+            &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+            module_hash,
+            &code_buf,
+        );
+        callbacks.asm_memory_buffer(
+            &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+            module_hash,
+            arch,
+            &code_buf,
+        )?;
+    }
 
     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..a1670eadfc 100644
--- a/lib/compiler-cranelift/src/trampoline/function_call.rs
+++ b/lib/compiler-cranelift/src/trampoline/function_call.rs
@@ -8,20 +8,29 @@
 //! let my_func = instance.exports.get("func");
 //! 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 crate::{
+    CraneliftCallbacks,
+    translator::{compiled_function_unwind_info, signature_to_cranelift_ir},
+};
+use cranelift_codegen::{
+    Context,
+    ir::{self, InstBuilder},
+    isa::TargetIsa,
+};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use std::mem;
-use wasmer_types::{CompileError, FunctionBody, FunctionType};
+use target_lexicon::Architecture;
+use wasmer_compiler::{misc::CompiledKind, types::function::FunctionBody};
+use wasmer_types::{CompileError, FunctionType};
 
 /// Create a trampoline for invoking a WebAssembly function.
 pub fn make_trampoline_function_call(
+    callbacks: &Option<CraneliftCallbacks>,
     isa: &dyn TargetIsa,
+    arch: Architecture,
     fn_builder_ctx: &mut FunctionBuilderContext,
     func_type: &FunctionType,
+    module_hash: &Option<String>,
 ) -> Result<FunctionBody, CompileError> {
     let pointer_type = isa.pointer_type();
     let frontend_config = isa.frontend_config();
@@ -100,11 +109,34 @@ pub fn make_trampoline_function_call(
         builder.finalize()
     }
 
-    let mut code_buf = Vec::new();
+    if let Some(callbacks) = callbacks.as_ref() {
+        callbacks.preopt_ir(
+            &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+            module_hash,
+            context.func.display().to_string().as_bytes(),
+        );
+    }
 
-    context
-        .compile_and_emit(isa, &mut code_buf)
+    let mut code_buf = Vec::new();
+    let mut ctrl_plane = Default::default();
+    let compiled = context
+        .compile(isa, &mut ctrl_plane)
         .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+    code_buf.extend_from_slice(compiled.code_buffer());
+
+    if let Some(callbacks) = callbacks.as_ref() {
+        callbacks.obj_memory_buffer(
+            &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+            module_hash,
+            &code_buf,
+        );
+        callbacks.asm_memory_buffer(
+            &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+            module_hash,
+            arch,
+            &code_buf,
+        )?;
+    }
 
     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..54a80a608a 100644
--- a/lib/compiler-cranelift/src/translator/code_translator.rs
+++ b/lib/compiler-cranelift/src/translator/code_translator.rs
@@ -21,7 +21,7 @@
 //! - the `get_global` and `set_global` instructions depend on how the globals are implemented;
 //! - `memory.size` and `memory.grow` are runtime functions;
 //! - `call_indirect` has to translate the function index into the address of where this
-//!    is;
+//!   is;
 //!
 //! That is why `translate_function_body` takes an object having the `WasmRuntime` trait as
 //! argument.
@@ -74,30 +74,54 @@
 //!   <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;
+
+pub(crate) const TAG_TYPE: ir::Type = I32;
+pub(crate) const EXN_REF_TYPE: ir::Type = I32;
+
+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 crate::{HashMap, hash_map};
 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::*;
 use cranelift_codegen::ir::{
-    self, AtomicRmwOp, ConstantData, InstBuilder, JumpTableData, MemFlags, Value, ValueLabel,
+    self, AtomicRmwOp, BlockArg, ConstantData, InstBuilder, JumpTableData, MemFlags, Value,
+    ValueLabel,
 };
 use cranelift_codegen::packed_option::ReservedValue;
 use cranelift_frontend::{FunctionBuilder, Variable};
+use itertools::Itertools;
 use smallvec::SmallVec;
 use std::vec::Vec;
 
-use wasmer_compiler::wasmparser::{MemArg, Operator};
-use wasmer_compiler::{from_binaryreadererror_wasmerror, wasm_unsupported, ModuleTranslationState};
+use wasmer_compiler::wasmparser::{self, Catch, MemArg, Operator};
+use wasmer_compiler::{ModuleTranslationState, from_binaryreadererror_wasmerror, wasm_unsupported};
 use wasmer_types::{
-    FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
+    CATCH_ALL_TAG_VALUE, FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex,
+    TagIndex, 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 +180,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 +211,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,14 +241,23 @@ 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 => {
             // We do nothing
         }
         Operator::Unreachable => {
-            builder.ins().trap(ir::TrapCode::UnreachableCodeReached);
+            builder.ins().trap(crate::TRAP_UNREACHABLE);
             state.reachable = false;
         }
         /***************************** Control flow blocks **********************************
@@ -257,7 +296,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 +307,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 +380,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 +396,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
                             }
@@ -371,18 +436,18 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         }
         Operator::End => {
             let frame = state.control_stack.pop().unwrap();
+            frame.restore_catch_handlers(&mut state.handlers, builder);
             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 +521,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 +532,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 +559,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 +569,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 +581,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,29 +589,23 @@ 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 { .. }
-        | Operator::Throw { .. }
         | Operator::Rethrow { .. }
         | Operator::Delegate { .. }
         | Operator::CatchAll => {
@@ -553,6 +614,67 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 op
             ));
         }
+        Operator::TryTable { try_table } => {
+            let body = builder.create_block();
+            let (params, results) =
+                module_translation_state.blocktype_params_results(&try_table.ty)?;
+            let next = block_with_params(builder, results.iter(), environ)?;
+            builder.ins().jump(body, &[]);
+            builder.seal_block(body);
+
+            let checkpoint = state.handlers.take_checkpoint();
+            let mut clauses = Vec::with_capacity(try_table.catches.len());
+            let outer_clauses = state.handlers.unique_clauses().into_iter().collect_vec();
+            let mut catch_blocks = Vec::with_capacity(try_table.catches.len() + 1);
+
+            let catches = try_table
+                .catches
+                .iter()
+                .unique_by(|v| match v {
+                    Catch::One { tag, .. } | Catch::OneRef { tag, .. } => *tag as i32,
+                    Catch::All { .. } | Catch::AllRef { .. } => CATCH_ALL_TAG_VALUE,
+                })
+                .collect_vec();
+
+            for catch in catches.iter().rev() {
+                let clause = create_catch_block(builder, state, catch, environ)?;
+                catch_blocks.push(clause.block);
+                state.handlers.add_clause(clause.clone());
+                clauses.push(clause);
+            }
+
+            let outer_clauses = outer_clauses
+                .into_iter()
+                .filter(|clause| clauses.iter().all(|c| c.tag_value != clause.tag_value))
+                .collect_vec();
+
+            if !clauses.is_empty() {
+                let dispatch_block = create_dispatch_block(
+                    builder,
+                    environ,
+                    clauses.iter().chain(outer_clauses.iter()).cloned(),
+                )?;
+                catch_blocks.push(dispatch_block);
+                state.handlers.add_handler(dispatch_block);
+            }
+
+            state.push_try_table_block(next, catch_blocks, params.len(), results.len(), checkpoint);
+
+            builder.switch_to_block(body);
+        }
+        Operator::Throw { tag_index } => {
+            let tag_index = TagIndex::from_u32(*tag_index);
+            let arity = environ.tag_param_arity(tag_index);
+            let args = state.peekn(arity);
+            environ.translate_exn_throw(builder, tag_index, args, state.handlers.landing_pad())?;
+            state.popn(arity);
+            state.reachable = false;
+        }
+        Operator::ThrowRef => {
+            let exnref = state.pop1();
+            environ.translate_exn_throw_ref(builder, exnref, state.handlers.landing_pad())?;
+            state.reachable = false;
+        }
         /************************************ Calls ****************************************
          * The call instructions pop off their arguments from the stack and append their
          * return values to it. `call_indirect` needs environment support because there is an
@@ -561,74 +683,72 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::Call { function_index } => {
             let (fref, num_args) = state.get_direct_func(builder.func, *function_index, environ)?;
 
-            let args = state.peekn_mut(num_args);
-
             // 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 inst_results = builder.inst_results(call);
+            {
+                let args_mut = state.peekn_mut(num_args);
+                bitcast_wasm_params(
+                    environ,
+                    builder.func.dfg.ext_funcs[fref].signature,
+                    args_mut,
+                    builder,
+                );
+            }
+            let args = state.peekn(num_args);
+            let results = environ.translate_call(
+                builder,
+                FunctionIndex::from_u32(*function_index),
+                fref,
+                args,
+                state.handlers.landing_pad(),
+            )?;
+            let sig_ref = builder.func.dfg.ext_funcs[fref].signature;
             debug_assert_eq!(
-                inst_results.len(),
-                builder.func.dfg.signatures[builder.func.dfg.ext_funcs[fref].signature]
-                    .returns
-                    .len(),
+                results.len(),
+                builder.func.dfg.signatures[sig_ref].returns.len(),
                 "translate_call results should match the call signature"
             );
             state.popn(num_args);
-            state.pushn(inst_results);
+            state.pushn(results.as_slice());
         }
         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_mut = state.peekn_mut(num_args);
+                bitcast_wasm_params(environ, sigref, args_mut, builder);
+            }
             let args = state.peekn(num_args);
-            let sig_idx = SignatureIndex::from_u32(*type_index);
-
-            let call = environ.translate_call_indirect(
-                builder.cursor(),
+            let results = environ.translate_call_indirect(
+                builder,
                 TableIndex::from_u32(*table_index),
-                table,
-                sig_idx,
+                SignatureIndex::from_u32(*type_index),
                 sigref,
                 callee,
                 args,
+                state.handlers.landing_pad(),
             )?;
-            let inst_results = builder.inst_results(call);
             debug_assert_eq!(
-                inst_results.len(),
+                results.len(),
                 builder.func.dfg.signatures[sigref].returns.len(),
                 "translate_call_indirect results should match the call signature"
             );
             state.popn(num_args);
-            state.pushn(inst_results);
+            state.pushn(results.as_slice());
         }
         /******************************* Memory management ***********************************
          * 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 +756,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 +766,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 +927,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)));
@@ -1079,7 +1265,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 }
                 Err(wasmer_types::WasmError::Unsupported(_err)) => {
                     // If multiple threads hit a mutex then the function will fail
-                    builder.ins().trap(ir::TrapCode::UnreachableCodeReached);
+                    builder.ins().trap(crate::TRAP_UNREACHABLE);
                     state.reachable = false;
                 }
                 Err(err) => {
@@ -1356,56 +1542,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 +1595,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 +1602,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 builder.cursor(),
                 *elem_index,
                 TableIndex::from_u32(*table_index),
-                table,
                 dest,
                 src,
                 len,
@@ -1463,26 +1634,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 +1668,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 +1738,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 +1948,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 +1994,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 +2144,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);
@@ -2053,11 +2257,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::I16x8RelaxedQ15mulrS => {
             return Err(wasm_unsupported!("proposed relaxed-simd operator {:?}", op));
         }
-        Operator::TryTable { .. } | Operator::ThrowRef => {
-            return Err(wasm_unsupported!(
-                "exceptions are not supported (operator: {op:?})"
-            ));
-        }
         Operator::RefEq
         | Operator::StructNew { .. }
         | Operator::StructNewDefault { .. }
@@ -2088,7 +2287,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 +2298,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,13 +2377,16 @@ 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,
                 blockty,
             );
         }
-        Operator::Loop { blockty: _ } | Operator::Block { blockty: _ } => {
+        Operator::Loop { blockty: _ }
+        | Operator::Block { blockty: _ }
+        | Operator::TryTable { try_table: _ } => {
             state.push_block(ir::Block::reserved_value(), 0, 0);
         }
         Operator::Else => {
@@ -2150,7 +2407,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 +2419,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
                             }
@@ -2185,6 +2449,7 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
             let stack = &mut state.stack;
             let control_stack = &mut state.control_stack;
             let frame = control_stack.pop().unwrap();
+            frame.restore_catch_handlers(&mut state.handlers, builder);
 
             // Pop unused parameters from stack.
             frame.truncate_value_stack_to_original_size(stack);
@@ -2236,29 +2501,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 +2576,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::HEAP_OUT_OF_BOUNDS);
+            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, crate::TRAP_HEAP_MISALIGNED);
+    }
+}
 
-    // 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 +2752,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 +2777,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:?}"),
     }
 }
 
@@ -2432,7 +2826,7 @@ fn fold_atomic_mem_addr(
         let r = builder
             .ins()
             .icmp_imm(IntCC::UnsignedGreaterThanOrEqual, a, 0x1_0000_0000i64);
-        builder.ins().trapnz(r, ir::TrapCode::HeapOutOfBounds);
+        builder.ins().trapnz(r, ir::TrapCode::HEAP_OUT_OF_BOUNDS);
         builder.ins().ireduce(I32, a)
     } else {
         linear_mem_addr
@@ -2444,62 +2838,10 @@ fn fold_atomic_mem_addr(
     let f = builder
         .ins()
         .icmp_imm(IntCC::Equal, final_lma_misalignment, i64::from(0));
-    builder.ins().trapz(f, ir::TrapCode::HeapMisaligned);
+    builder.ins().trapz(f, crate::TRAP_HEAP_MISALIGNED);
     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 +2851,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
@@ -2520,7 +2862,7 @@ fn translate_atomic_rmw<FE: FuncEnvironment + ?Sized>(
             return Err(wasm_unsupported!(
                 "atomic_rmw: unsupported access type {:?}",
                 access_ty
-            ))
+            ));
         }
     };
     let w_ty_ok = matches!(widened_ty, I32 | I64);
@@ -2531,22 +2873,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 +2899,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);
 
@@ -2567,7 +2911,7 @@ fn translate_atomic_cas<FE: FuncEnvironment + ?Sized>(
             return Err(wasm_unsupported!(
                 "atomic_cas: unsupported access type {:?}",
                 access_ty
-            ))
+            ));
         }
     };
     let w_ty_ok = matches!(widened_ty, I32 | I64);
@@ -2582,15 +2926,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 +2952,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 {
@@ -2616,21 +2960,23 @@ fn translate_atomic_load<FE: FuncEnvironment + ?Sized>(
             return Err(wasm_unsupported!(
                 "atomic_load: unsupported access type {:?}",
                 access_ty
-            ))
+            ));
         }
     };
     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 +2991,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
@@ -2656,7 +3002,7 @@ fn translate_atomic_store<FE: FuncEnvironment + ?Sized>(
             return Err(wasm_unsupported!(
                 "atomic_store: unsupported access type {:?}",
                 access_ty
-            ))
+            ));
         }
     };
     let d_ty_ok = matches!(data_ty, I32 | I64);
@@ -2666,15 +3012,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 +3063,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);
 }
@@ -2979,22 +3326,13 @@ fn is_non_canonical_v128(ty: ir::Type) -> bool {
 /// actually necessary, and if not, the original slice is returned.  Otherwise the cast values
 /// are returned in a slice that belongs to the caller-supplied `SmallVec`.
 fn canonicalise_v128_values<'a>(
-    tmp_canonicalised: &'a mut SmallVec<[ir::Value; 16]>,
+    tmp_canonicalised: &'a mut SmallVec<[ir::BlockArg; 16]>,
     builder: &mut FunctionBuilder,
     values: &'a [ir::Value],
-) -> &'a [ir::Value] {
+) -> &'a [ir::BlockArg] {
     debug_assert!(tmp_canonicalised.is_empty());
-    // First figure out if any of the parameters need to be cast.  Mostly they don't need to be.
-    let any_non_canonical = values
-        .iter()
-        .any(|v| is_non_canonical_v128(builder.func.dfg.value_type(*v)));
-    // Hopefully we take this exit most of the time, hence doing no heap allocation.
-    if !any_non_canonical {
-        return values;
-    }
-    // Otherwise we'll have to cast, and push the resulting `Value`s into `canonicalised`.
     for v in values {
-        tmp_canonicalised.push(if is_non_canonical_v128(builder.func.dfg.value_type(*v)) {
+        let value = if is_non_canonical_v128(builder.func.dfg.value_type(*v)) {
             builder.ins().bitcast(
                 I8X16,
                 MemFlags::new().with_endianness(ir::Endianness::Little),
@@ -3002,7 +3340,8 @@ fn canonicalise_v128_values<'a>(
             )
         } else {
             *v
-        });
+        };
+        tmp_canonicalised.push(BlockArg::from(value));
     }
     tmp_canonicalised.as_slice()
 }
@@ -3015,33 +3354,33 @@ fn canonicalise_then_jump(
     destination: ir::Block,
     params: &[ir::Value],
 ) -> ir::Inst {
-    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
+    let mut tmp_canonicalised = SmallVec::<[_; 16]>::new();
     let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
     builder.ins().jump(destination, canonicalised)
 }
 
-/// The same but for a `brz` instruction.
-fn canonicalise_then_brz(
+/// 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().brz(cond, destination, canonicalised)
-}
-
-/// The same but for a `brnz` instruction.
-fn canonicalise_then_brnz(
-    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().brnz(cond, destination, canonicalised)
+    let mut tmp_canonicalised_then = SmallVec::<[_; 16]>::new();
+    let canonicalised_then =
+        canonicalise_v128_values(&mut tmp_canonicalised_then, builder, params_then);
+    let mut tmp_canonicalised_else = SmallVec::<[_; 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 +3408,217 @@ 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);
+    }
+}
+
+/// 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);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct CatchClause {
+    pub(crate) wasm_tag: Option<u32>,
+    pub(crate) tag_value: i32,
+    pub(crate) block: ir::Block,
+}
+
+fn create_catch_block<FE: FuncEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    catch: &wasmparser::Catch,
+    environ: &mut FE,
+) -> WasmResult<CatchClause> {
+    let (is_ref, wasm_tag, label) = match catch {
+        wasmparser::Catch::One { tag, label } => (false, Some(*tag), *label),
+        wasmparser::Catch::OneRef { tag, label } => (true, Some(*tag), *label),
+        wasmparser::Catch::All { label } => (false, None, *label),
+        wasmparser::Catch::AllRef { label } => (true, None, *label),
+    };
+
+    let tag_value = wasm_tag.map_or(CATCH_ALL_TAG_VALUE, |t| t as i32);
+
+    let block = builder.create_block();
+    let exnref = builder.append_block_param(block, EXN_REF_TYPE);
+
+    builder.switch_to_block(block);
+
+    let mut params = SmallVec::<[Value; 4]>::new();
+    if let Some(tag) = wasm_tag {
+        let tag_index = TagIndex::from_u32(tag);
+        params.extend(environ.translate_exn_unbox(builder, tag_index, exnref)?);
+    }
+    if is_ref {
+        params.push(exnref);
     }
+
+    let depth = label as usize;
+    let idx = state.control_stack.len() - 1 - depth;
+    let frame = &mut state.control_stack[idx];
+    frame.set_branched_to_exit();
+    canonicalise_then_jump(builder, frame.br_destination(), params.as_slice());
+
+    Ok(CatchClause {
+        wasm_tag,
+        tag_value,
+        block,
+    })
 }
 
-/// 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);
+fn create_dispatch_block<FE: FuncEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    environ: &mut FE,
+    clauses: impl Iterator<Item = CatchClause>,
+) -> WasmResult<ir::Block> {
+    let clauses = clauses.collect_vec();
+
+    let catch_block = builder.create_block();
+    let exn_ptr = builder.append_block_param(catch_block, environ.reference_type());
+    let pre_selector = builder.append_block_param(catch_block, I64);
+    let catch_all_block = builder.create_block();
+    let catch_one_block = builder.create_block();
+    let dispatch_block = builder.create_block();
+
+    builder.switch_to_block(catch_block);
+    let catch_all_tag = builder.ins().iconst(I64, 0);
+    let matches = builder
+        .ins()
+        .icmp(IntCC::Equal, pre_selector, catch_all_tag);
+    canonicalise_brif(builder, matches, catch_all_block, &[], catch_one_block, &[]);
+
+    builder.switch_to_block(catch_all_block);
+    let catch_all_tag = builder
+        .ins()
+        .iconst(TAG_TYPE, i64::from(CATCH_ALL_TAG_VALUE));
+    canonicalise_then_jump(builder, dispatch_block, &[catch_all_tag]);
+    builder.seal_block(catch_all_block);
+
+    builder.switch_to_block(catch_one_block);
+    let selector = environ.translate_exn_personality_selector(builder, exn_ptr)?;
+    canonicalise_then_jump(builder, dispatch_block, &[selector]);
+    builder.seal_block(catch_one_block);
+
+    builder.switch_to_block(dispatch_block);
+    let selector = builder.append_block_param(dispatch_block, TAG_TYPE);
+    let exnref = environ.translate_exn_pointer_to_ref(builder, exn_ptr);
+
+    let rethrow_block = builder.create_block();
+    builder.append_block_param(rethrow_block, EXN_REF_TYPE);
+
+    let mut current_selector = selector;
+    let mut current_exn = exnref;
+
+    for (idx, clause) in clauses.iter().enumerate() {
+        let tag_value = builder.ins().iconst(TAG_TYPE, i64::from(clause.tag_value));
+        let matches = builder
+            .ins()
+            .icmp(IntCC::Equal, current_selector, tag_value);
+
+        if idx + 1 == clauses.len() {
+            canonicalise_brif(
+                builder,
+                matches,
+                clause.block,
+                &[current_exn],
+                rethrow_block,
+                &[exnref],
+            );
+        } else {
+            let continue_block = builder.create_block();
+            builder.append_block_param(continue_block, TAG_TYPE);
+            builder.append_block_param(continue_block, EXN_REF_TYPE);
+
+            canonicalise_brif(
+                builder,
+                matches,
+                clause.block,
+                &[current_exn],
+                continue_block,
+                &[current_selector, current_exn],
+            );
+
+            builder.seal_block(continue_block);
+            builder.switch_to_block(continue_block);
+            let params = builder.func.dfg.block_params(continue_block);
+            current_selector = params[0];
+            current_exn = params[1];
         }
     }
-    ret
+    builder.seal_block(dispatch_block);
+
+    builder.switch_to_block(rethrow_block);
+    let rethrow_exn = builder.func.dfg.block_params(rethrow_block)[0];
+    environ.translate_exn_reraise_unmatched(builder, rethrow_exn)?;
+    builder.seal_block(rethrow_block);
+
+    Ok(catch_block)
 }
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..bae55f7957
--- /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 Reachability::*;
+use cranelift_codegen::{
+    cursor::{Cursor, FuncCursor},
+    ir::{self, InstBuilder, RelSourceLoc, condcodes::IntCC},
+    ir::{Expr, Fact},
+};
+use cranelift_frontend::FunctionBuilder;
+use wasmer_types::WasmResult;
+
+/// 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::HEAP_OUT_OF_BOUNDS,
+            );
+            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::HEAP_OUT_OF_BOUNDS);
+            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::HEAP_OUT_OF_BOUNDS);
+    }
+
+    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..1cf9d1df08 100644
--- a/lib/compiler-cranelift/src/translator/func_environ.rs
+++ b/lib/compiler-cranelift/src/translator/func_environ.rs
@@ -6,16 +6,20 @@
 
 use super::func_state::FuncTranslationState;
 use super::translation_utils::reference_type;
+use crate::heap::{Heap, HeapData};
+use crate::translator::func_state::LandingPad;
 use core::convert::From;
 use cranelift_codegen::cursor::FuncCursor;
 use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
-use wasmer_compiler::wasmparser::{HeapType, Operator};
+use smallvec::SmallVec;
+use wasmer_compiler::wasmparser::{AbstractHeapType, HeapType, Operator};
+use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
-    TableIndex, Type as WasmerType, WasmResult,
+    TableIndex, TagIndex, Type as WasmerType, WasmResult,
 };
 
 /// The value of a WebAssembly global variable.
@@ -68,7 +72,7 @@ pub trait TargetEnvironment {
 
     /// Get the Cranelift reference type to use for native references.
     ///
-    /// This returns `R64` for 64-bit architectures and `R32` for 32-bit architectures.
+    /// This returns the target pointer type for both `funcref` and `externref`.
     fn reference_type(&self) -> ir::Type {
         reference_type(self.target_config()).expect("expected reference type")
     }
@@ -80,6 +84,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 +122,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 +178,22 @@ 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],
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>>;
+
     /// Translate a `call_indirect` WebAssembly instruction at `pos`.
     ///
     /// Insert instructions at `pos` for an indirect call to the function `callee` in the table
@@ -165,34 +203,68 @@ 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.
+    /// Returns `None` if this statically traps instead of creating a call
+    /// instruction.
     #[allow(clippy::too_many_arguments)]
     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>;
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>>;
 
-    /// 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(
+    /// Return the number of WebAssembly values contained in the payload for the given exception tag.
+    fn tag_param_arity(&self, tag_index: TagIndex) -> usize;
+
+    /// Get the exception reference from the raw exception pointer (used by libunwind).
+    fn translate_exn_pointer_to_ref(
         &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))
-    }
+        builder: &mut FunctionBuilder,
+        exn_ptr: ir::Value,
+    ) -> ir::Value;
+
+    /// Extract the payload values from an exception reference produced by the given tag.
+    fn translate_exn_unbox(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        tag_index: TagIndex,
+        exnref: ir::Value,
+    ) -> WasmResult<SmallVec<[ir::Value; 4]>>;
+
+    /// Emit IR to allocate and throw a new exception with the specified tag.
+    fn translate_exn_throw(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        tag_index: TagIndex,
+        args: &[ir::Value],
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<()>;
+
+    /// Emit IR to rethrow an existing exception reference.
+    fn translate_exn_throw_ref(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exnref: ir::Value,
+        landing_pad: Option<LandingPad>,
+    ) -> WasmResult<()>;
+
+    /// Invoke the runtime personality helper to choose the matching catch tag for an exception.
+    fn translate_exn_personality_selector(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exn_ptr: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Reraise an exception when no catch clause within the current handler matches.
+    fn translate_exn_reraise_unmatched(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        exnref: ir::Value,
+    ) -> WasmResult<()>;
 
     /// Translate a `memory.grow` WebAssembly instruction.
     ///
@@ -206,7 +278,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         val: ir::Value,
     ) -> WasmResult<ir::Value>;
 
@@ -220,7 +292,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 +304,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 +320,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 +336,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 +347,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 +364,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         index: ir::Value,
     ) -> WasmResult<ir::Value>;
 
@@ -306,7 +372,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 +382,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 +405,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,
@@ -360,11 +422,16 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// null sentinel is not a null reference type pointer for your type. If you
     /// override this method, then you should also override
     /// `translate_ref_is_null` as well.
-    fn translate_ref_null(&mut self, pos: FuncCursor, ty: HeapType) -> WasmResult<ir::Value>;
-    // {
-    //     let _ = ty;
-    //     Ok(pos.ins().null(self.reference_type(ty)))
-    // }
+    fn translate_ref_null(&mut self, mut pos: FuncCursor, ty: HeapType) -> WasmResult<ir::Value> {
+        let ty = match ty {
+            HeapType::Abstract {
+                ty: AbstractHeapType::Exn,
+                ..
+            } => ir::types::I32,
+            _ => self.reference_type(),
+        };
+        Ok(pos.ins().iconst(ty, 0))
+    }
 
     /// Translate a `ref.is_null` WebAssembly instruction.
     ///
@@ -379,8 +446,10 @@ pub trait FuncEnvironment: TargetEnvironment {
         mut pos: FuncCursor,
         value: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let is_null = pos.ins().is_null(value);
-        Ok(pos.ins().uextend(ir::types::I64, is_null))
+        let is_null = pos
+            .ins()
+            .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::Equal, value, 0);
+        Ok(pos.ins().uextend(ir::types::I32, is_null))
     }
 
     /// Translate a `ref.func` WebAssembly instruction.
@@ -418,7 +487,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 +503,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 +539,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 +576,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..8f320e12b8 100644
--- a/lib/compiler-cranelift/src/translator/func_state.rs
+++ b/lib/compiler-cranelift/src/translator/func_state.rs
@@ -10,11 +10,15 @@
 //! value and control stacks during the translation of a single function.
 
 use super::func_environ::{FuncEnvironment, GlobalVariable};
+use crate::heap::Heap;
+use crate::translator::code_translator::CatchClause;
 use crate::{HashMap, Occupied, Vacant};
 use cranelift_codegen::ir::{self, Block, Inst, Value};
+use cranelift_frontend::FunctionBuilder;
+use itertools::Itertools;
 use std::vec::Vec;
 use wasmer_types::{
-    FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
+    CATCH_ALL_TAG_VALUE, FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, WasmResult,
 };
 
 /// Information about the presence of an associated `else` for an `if`, or the
@@ -30,6 +34,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.
@@ -82,6 +89,9 @@ pub enum ControlStackFrame {
         num_return_values: usize,
         original_stack_size: usize,
         exit_is_branched_to: bool,
+        /// When this block corresponds to a try-table, keep the handler state
+        /// checkpoint and the list of catch blocks to seal once the scope ends.
+        try_table_info: Option<(HandlerStateCheckpoint, Vec<Block>)>,
     },
     Loop {
         destination: Block,
@@ -212,6 +222,25 @@ impl ControlStackFrame {
         };
         stack.truncate(self.original_stack_size() - num_duplicated_params);
     }
+
+    /// Restore exception handler state and seal catch blocks when exiting a
+    /// try-table scope.
+    pub fn restore_catch_handlers(
+        &self,
+        handlers: &mut HandlerState,
+        builder: &mut FunctionBuilder,
+    ) {
+        if let Self::Block {
+            try_table_info: Some((checkpoint, catch_blocks)),
+            ..
+        } = self
+        {
+            handlers.restore_checkpoint(*checkpoint);
+            for block in catch_blocks {
+                builder.seal_block(*block);
+            }
+        }
+    }
 }
 
 /// Contains information passed along during a function's translation and that records:
@@ -225,6 +254,8 @@ pub struct FuncTranslationState {
     pub(crate) stack: Vec<Value>,
     /// A stack of active control flow operations at this point in the input wasm function.
     pub(crate) control_stack: Vec<ControlStackFrame>,
+    /// Exception handler state used to attach catch blocks to try-calls.
+    pub(crate) handlers: HandlerState,
     /// Is the current translation state still reachable? This is false when translating operators
     /// like End, Return, or Unreachable.
     pub(crate) reachable: bool,
@@ -233,10 +264,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()`.
@@ -259,6 +287,72 @@ impl FuncTranslationState {
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct HandlerStateCheckpoint(usize, usize);
+
+#[derive(Default)]
+pub(crate) struct HandlerState {
+    handlers: Vec<Block>,
+    clauses: Vec<CatchClause>,
+}
+
+#[derive(Debug)]
+pub(crate) struct LandingPad {
+    pub(crate) block: Block,
+    pub(crate) clauses: Vec<CatchClause>,
+}
+
+impl HandlerState {
+    pub fn add_handler(&mut self, block: Block) {
+        self.handlers.push(block);
+    }
+
+    pub fn add_clause(&mut self, clause: CatchClause) {
+        self.clauses.push(clause);
+    }
+
+    pub fn take_checkpoint(&self) -> HandlerStateCheckpoint {
+        HandlerStateCheckpoint(self.handlers.len(), self.clauses.len())
+    }
+
+    pub fn restore_checkpoint(&mut self, checkpoint: HandlerStateCheckpoint) {
+        debug_assert!(checkpoint.0 <= self.handlers.len());
+        debug_assert!(checkpoint.1 <= self.clauses.len());
+        self.handlers.truncate(checkpoint.0);
+        self.clauses.truncate(checkpoint.1);
+    }
+
+    /// Get the latest landing pad block including all the tags covered by it.
+    pub fn landing_pad(&self) -> Option<LandingPad> {
+        self.handlers.last().copied().map(|block| LandingPad {
+            block,
+            clauses: self.unique_clauses(),
+        })
+    }
+
+    /// Returns an iterator over the catch clauses in reverse order, with duplicates removed.
+    pub fn unique_clauses(&self) -> Vec<CatchClause> {
+        self.clauses
+            .iter()
+            // Starting with the inner-most try_table catch clauses.
+            .rev()
+            .unique_by(|c| c.tag_value)
+            // We can ignore every tag followed by the CatchAll.
+            .take_while_inclusive(|c| c.tag_value != CATCH_ALL_TAG_VALUE)
+            .cloned()
+            .collect()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.handlers.is_empty()
+    }
+
+    pub fn clear(&mut self) {
+        self.handlers.clear();
+        self.clauses.clear();
+    }
+}
+
 impl FuncTranslationState {
     /// Construct a new, empty, `FuncTranslationState`
     pub(crate) fn new() -> Self {
@@ -267,10 +361,10 @@ impl FuncTranslationState {
             // TODO(reftypes):
             //metadata_stack: Vec::new(),
             control_stack: Vec::new(),
+            handlers: HandlerState::default(),
             reachable: true,
             globals: HashMap::new(),
             heaps: HashMap::new(),
-            tables: HashMap::new(),
             signatures: HashMap::new(),
             functions: HashMap::new(),
         }
@@ -279,10 +373,11 @@ impl FuncTranslationState {
     fn clear(&mut self) {
         debug_assert!(self.stack.is_empty());
         debug_assert!(self.control_stack.is_empty());
+        debug_assert!(self.handlers.is_empty());
         self.reachable = true;
+        self.handlers.clear();
         self.globals.clear();
         self.heaps.clear();
-        self.tables.clear();
         self.signatures.clear();
         self.functions.clear();
     }
@@ -377,12 +472,12 @@ impl FuncTranslationState {
         &mut self.stack[len - n..]
     }
 
-    /// Push a block on the control stack.
-    pub(crate) fn push_block(
+    fn push_block_impl(
         &mut self,
         following_code: Block,
         num_param_types: usize,
         num_result_types: usize,
+        try_table_info: Option<(HandlerStateCheckpoint, Vec<Block>)>,
     ) {
         debug_assert!(num_param_types <= self.stack.len());
         self.control_stack.push(ControlStackFrame::Block {
@@ -391,9 +486,37 @@ impl FuncTranslationState {
             num_param_values: num_param_types,
             num_return_values: num_result_types,
             exit_is_branched_to: false,
+            try_table_info,
         });
     }
 
+    /// Push a block on the control stack.
+    pub(crate) fn push_block(
+        &mut self,
+        following_code: Block,
+        num_param_types: usize,
+        num_result_types: usize,
+    ) {
+        self.push_block_impl(following_code, num_param_types, num_result_types, None);
+    }
+
+    /// Push a try-table block on the control stack.
+    pub(crate) fn push_try_table_block(
+        &mut self,
+        following_code: Block,
+        catch_blocks: Vec<Block>,
+        num_param_types: usize,
+        num_result_types: usize,
+        checkpoint: HandlerStateCheckpoint,
+    ) {
+        self.push_block_impl(
+            following_code,
+            num_param_types,
+            num_result_types,
+            Some((checkpoint, catch_blocks)),
+        );
+    }
+
     /// Push a loop on the control stack.
     pub(crate) fn push_loop(
         &mut self,
@@ -473,7 +596,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 +604,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..5ff2595bfa 100644
--- a/lib/compiler-cranelift/src/translator/func_translator.rs
+++ b/lib/compiler-cranelift/src/translator/func_translator.rs
@@ -7,16 +7,20 @@
 //! 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::EXN_REF_TYPE;
+use crate::translator::code_translator::bitcast_wasm_returns;
+use core::convert::TryFrom;
 use cranelift_codegen::entity::EntityRef;
 use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
-use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
+use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
+use wasmer_compiler::wasmparser::RefType;
+use wasmer_compiler::{FunctionBinaryReader, ModuleTranslationState, wptype_to_type};
 use wasmer_compiler::{wasm_unsupported, wasmparser};
-use wasmer_compiler::{wptype_to_type, FunctionBinaryReader, ModuleTranslationState};
 use wasmer_types::{LocalFunctionIndex, WasmResult};
 
 /// WebAssembly to Cranelift IR function translator.
@@ -136,8 +140,10 @@ fn declare_wasm_parameters<FE: FuncEnvironment + ?Sized>(
         // signature parameters. For example, a `vmctx` pointer.
         if environ.is_wasm_parameter(&builder.func.signature, i) {
             // This is a normal WebAssembly signature parameter, so create a local for it.
-            let local = Variable::new(next_local);
-            builder.declare_var(local, param_type.value_type);
+            let local = builder.declare_var(param_type.value_type);
+            let local_index = local.index();
+            debug_assert_eq!(local_index, next_local);
+            debug_assert!(u32::try_from(local_index).is_ok());
             next_local += 1;
 
             let param_value = builder.block_params(entry_block)[i];
@@ -196,7 +202,10 @@ fn declare_locals<FE: FuncEnvironment + ?Sized>(
         }
         Ref(ty) => {
             if ty.is_func_ref() || ty.is_extern_ref() {
-                builder.ins().null(environ.reference_type())
+                builder.ins().iconst(environ.reference_type(), 0)
+            } else if ty == RefType::EXNREF || ty == RefType::EXN {
+                // no `.is_exnref` yet
+                builder.ins().iconst(EXN_REF_TYPE, 0)
             } else {
                 return Err(wasm_unsupported!("unsupported reference type: {:?}", ty));
             }
@@ -206,8 +215,10 @@ fn declare_locals<FE: FuncEnvironment + ?Sized>(
     let wasmer_ty = wptype_to_type(wasm_type).unwrap();
     let ty = builder.func.dfg.value_type(zeroval);
     for _ in 0..count {
-        let local = Variable::new(*next_local);
-        builder.declare_var(local, ty);
+        let local = builder.declare_var(ty);
+        let local_index = local.index();
+        debug_assert_eq!(local_index, *next_local);
+        debug_assert!(u32::try_from(local_index).is_ok());
         builder.def_var(local, zeroval);
         builder.set_val_label(zeroval, ValueLabel::new(*next_local));
         environ.push_local_decl_on_stack(wasmer_ty);
@@ -249,10 +260,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..e140739def 100644
--- a/lib/compiler-cranelift/src/translator/mod.rs
+++ b/lib/compiler-cranelift/src/translator/mod.rs
@@ -10,6 +10,13 @@ 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,
+};
+#[cfg(feature = "unwind")]
+pub(crate) use self::unwind::CraneliftUnwindInfo;
+pub(crate) use self::unwind::compiled_function_unwind_info;
+
+pub(crate) use {
+    self::code_translator::EXN_REF_TYPE, self::code_translator::TAG_TYPE,
+    self::func_state::LandingPad,
 };
-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..07442374f7 100644
--- a/lib/compiler-cranelift/src/translator/translation_utils.rs
+++ b/lib/compiler-cranelift/src/translator/translation_utils.rs
@@ -1,14 +1,19 @@
 //! Helper functions and structures for the translation.
 
+use crate::translator::EXN_REF_TYPE;
+
 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,
+    wasmparser::{self, RefType},
+};
+use wasmer_types::{FunctionType, LibCall, Type, WasmError, WasmResult};
 
 /// Helper function translate a Function signature into Cranelift Ir
 pub fn signature_to_cranelift_ir(
@@ -36,13 +41,7 @@ pub fn signature_to_cranelift_ir(
 
 /// Helper function translating wasmparser types to Cranelift types when possible.
 pub fn reference_type(target_config: TargetFrontendConfig) -> WasmResult<ir::Type> {
-    match target_config.pointer_type() {
-        ir::types::I32 => Ok(ir::types::R32),
-        ir::types::I64 => Ok(ir::types::R64),
-        _ => Err(WasmError::Unsupported(
-            "unsupported pointer type".to_string(),
-        )),
-    }
+    Ok(target_config.pointer_type())
 }
 
 /// Helper function translating wasmparser types to Cranelift types when possible.
@@ -54,6 +53,7 @@ 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 => Ok(EXN_REF_TYPE),
         // ty => Err(wasm_unsupported!("type_to_type: wasm type {:?}", ty)),
     }
 }
@@ -79,13 +79,13 @@ pub fn irreloc_to_relocationkind(reloc: Reloc) -> RelocationKind {
     match reloc {
         Reloc::Abs4 => RelocationKind::Abs4,
         Reloc::Abs8 => RelocationKind::Abs8,
-        Reloc::X86PCRel4 => RelocationKind::X86PCRel4,
+        Reloc::X86PCRel4 => RelocationKind::PCRel4,
         Reloc::X86CallPCRel4 => RelocationKind::X86CallPCRel4,
         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."),
     }
 }
 
@@ -113,10 +113,12 @@ pub fn block_with_params<'a, PE: TargetEnvironment + ?Sized>(
             wasmparser::ValType::Ref(ty) => {
                 if ty.is_extern_ref() || ty.is_func_ref() {
                     builder.append_block_param(block, environ.reference_type());
+                } else if ty == &RefType::EXNREF || ty == &RefType::EXN {
+                    // no `.is_exnref` yet
+                    builder.append_block_param(block, EXN_REF_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..ed0510ef09 100644
--- a/lib/compiler-cranelift/src/translator/unwind.rs
+++ b/lib/compiler-cranelift/src/translator/unwind.rs
@@ -2,11 +2,12 @@
 //! module.
 
 #[cfg(feature = "unwind")]
-use cranelift_codegen::isa::unwind::{systemv::UnwindInfo as DwarfFDE, UnwindInfo};
+use cranelift_codegen::isa::unwind::{UnwindInfo, systemv::UnwindInfo as DwarfFDE};
+#[cfg(feature = "unwind")]
 use cranelift_codegen::print_errors::pretty_error;
-use cranelift_codegen::{isa, Context};
+use cranelift_codegen::{Context, isa};
+use wasmer_compiler::types::unwind::CompiledFunctionUnwindInfo;
 use wasmer_types::CompileError;
-use wasmer_types::CompiledFunctionUnwindInfo;
 
 /// Cranelift specific unwind info
 pub(crate) enum CraneliftUnwindInfo {
@@ -63,8 +64,8 @@ pub(crate) fn compiled_function_unwind_info(
 #[cfg(not(feature = "unwind"))]
 /// Constructs unwind info object from Cranelift IR
 pub(crate) fn compiled_function_unwind_info(
-    isa: &dyn isa::TargetIsa,
-    context: &Context,
+    _isa: &dyn isa::TargetIsa,
+    _context: &Context,
 ) -> Result<CraneliftUnwindInfo, CompileError> {
     Ok(CraneliftUnwindInfo::None)
 }
diff --git a/lib/compiler-llvm/Cargo.toml b/lib/compiler-llvm/Cargo.toml
index a0ae6dd9f3..7b3878c51e 100644
--- a/lib/compiler-llvm/Cargo.toml
+++ b/lib/compiler-llvm/Cargo.toml
@@ -8,37 +8,40 @@ 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 = "=7.0.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 = "=7.0.0" }
+wasmer-types = { path = "../types", version = "=7.0.0" }
+target-lexicon.workspace = true
+smallvec.workspace = true
+object = { workspace = true, features = ["read"] }
 libc.workspace = true
-byteorder = "1"
-itertools = "0.10"
-rayon = "1.5"
-
-[dependencies.inkwell]
-package = "inkwell"
-version = "0.1.1"
-default-features = false
-features = ["llvm15-0", "target-x86", "target-aarch64", "target-riscv"]
+byteorder.workspace = true
+itertools.workspace = true
+rayon.workspace = true
+phf = { workspace = true, features = ["macros"] }
+tracing = { workspace = true, features = ["log"] }
+inkwell = { workspace = true, features = [
+	"llvm21-1-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"
-rustc_version = "0.4"
+cc.workspace = true
+regex.workspace = true
+semver.workspace = true
+rustc_version.workspace = true
 
 [features]
 test = []
diff --git a/lib/compiler-llvm/LICENSE b/lib/compiler-llvm/LICENSE
new file mode 100644
index 0000000000..3dd28bf0ec
--- /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.
diff --git a/lib/compiler-llvm/README.md b/lib/compiler-llvm/README.md
index 124f5c48bb..eec852844c 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 21**.
 
 
 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 21
 ```
 
 Or in macOS:
 
 ```bash
-brew install llvm@15
+brew install llvm@21
 ```
 
 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..48b64eeae2 100644
--- a/lib/compiler-llvm/src/abi/aarch64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/aarch64_systemv.rs
@@ -1,12 +1,14 @@
 use crate::abi::Abi;
-use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+use crate::error::{err, err_nt};
+use crate::translator::intrinsics::{Intrinsics, type_to_llvm};
+use inkwell::values::BasicValue;
 use inkwell::{
+    AddressSpace,
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     context::Context,
     types::{AnyType, BasicMetadataTypeEnum, BasicType, FunctionType, StructType},
-    values::{BasicValue, BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue},
-    AddressSpace,
+    values::{BasicValueEnum, CallSiteValue, IntValue},
 };
 use wasmer_types::CompileError;
 use wasmer_types::{FunctionType as FuncSig, Type};
@@ -14,25 +16,12 @@ use wasmer_vm::VMOffsets;
 
 use std::convert::TryInto;
 
+use super::G0M0FunctionKind;
+
 /// 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
-            .get_nth_param(u32::from(
-                func_value
-                    .get_enum_attribute(
-                        AttributeLoc::Param(0),
-                        Attribute::get_named_enum_kind_id("sret"),
-                    )
-                    .is_some(),
-            ))
-            .unwrap()
-            .into_pointer_value()
-    }
-
     // Given a wasm function type, produce an llvm function declaration.
     fn func_type_to_llvm<'ctx>(
         &self,
@@ -40,11 +29,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,12 +153,33 @@ impl Abi for Aarch64SystemV {
                     vmctx_attributes(0),
                 )
             }
+            [t1, t2]
+                if matches!(
+                    t1,
+                    Type::I32 | Type::I64 | Type::F32 | Type::F64 | Type::ExceptionRef
+                ) && matches!(t2, Type::FuncRef | Type::ExternRef) =>
+            {
+                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()
                     .iter()
                     .map(|ty| match ty {
-                        Type::I32 | Type::F32 => 32,
+                        Type::I32 | Type::F32 | Type::ExceptionRef => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
                         Type::ExternRef | Type::FuncRef => 64, /* pointer */
@@ -202,7 +220,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);
@@ -232,42 +250,6 @@ impl Abi for Aarch64SystemV {
         })
     }
 
-    // Marshall wasm stack values into function parameters.
-    fn args_to_call<'ctx>(
-        &self,
-        alloca_builder: &Builder<'ctx>,
-        func_sig: &FuncSig,
-        llvm_fn_ty: &FunctionType<'ctx>,
-        ctx_ptr: PointerValue<'ctx>,
-        values: &[BasicValueEnum<'ctx>],
-        intrinsics: &Intrinsics<'ctx>,
-    ) -> Vec<BasicValueEnum<'ctx>> {
-        // 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
-                .results()
-                .iter()
-                .map(|x| type_to_llvm(intrinsics, *x).unwrap())
-                .collect();
-            let llvm_params = llvm_fn_ty
-                .get_context()
-                .struct_type(llvm_params.as_slice(), false);
-            Some(alloca_builder.build_alloca(llvm_params, "sret"))
-        } else {
-            None
-        };
-
-        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
-
-        if let Some(sret) = sret {
-            std::iter::once(sret.as_basic_value_enum())
-                .chain(values)
-                .collect()
-        } else {
-            values.collect()
-        }
-    }
-
     // Given a CallSite, extract the returned values and return them in a Vec.
     fn rets_from_call<'ctx>(
         &self,
@@ -275,72 +257,82 @@ 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 | Type::ExceptionRef => {
+                        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 => {
+                        assert!(value.get_type() == intrinsics.i64_ty.as_basic_type_enum());
+                        err_nt!(
+                            builder
+                                .build_int_to_ptr(value.into_int_value(), intrinsics.ptr_ty, "")
+                                .map(|ptr| ptr.as_basic_value_enum())
+                        )
+                    }
                 }
-            }
-        };
+            };
 
-        if let Some(basic_value) = call_site.try_as_basic_value().left() {
+        if let Some(basic_value) = call_site.try_as_basic_value().basic() {
             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
@@ -355,7 +347,7 @@ impl Abi for Aarch64SystemV {
                     .results()
                     .iter()
                     .map(|ty| match ty {
-                        Type::I32 | Type::F32 => 32,
+                        Type::I32 | Type::F32 | Type::ExceptionRef => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
                         Type::ExternRef | Type::FuncRef => 64, /* pointer */
@@ -364,58 +356,58 @@ impl Abi for Aarch64SystemV {
 
                 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.
@@ -428,12 +420,10 @@ impl Abi for Aarch64SystemV {
             {
                 let sret_ty = call_site
                     .try_as_basic_value()
-                    .right()
-                    .unwrap()
+                    .unwrap_instruction()
                     .get_operand(0)
                     .unwrap()
-                    .left()
-                    .unwrap();
+                    .unwrap_value();
                 let sret = sret_ty.into_pointer_value();
                 // re-build the llvm-type struct holding the return values
                 let llvm_results: Vec<_> = func_sig
@@ -446,49 +436,22 @@ 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![])
             }
         }
     }
 
-    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError> {
-        let func_sig_returns_bitwidths = func_sig
-            .results()
-            .iter()
-            .map(|ty| match ty {
-                Type::I32 | Type::F32 => 32,
-                Type::I64 | Type::F64 => 64,
-                Type::V128 => 128,
-                Type::ExternRef | Type::FuncRef => 64, /* pointer */
-            })
-            .collect::<Vec<i32>>();
-
-        Ok(!matches!(
-            func_sig_returns_bitwidths.as_slice(),
-            [] | [_]
-                | [32, 32]
-                | [32, 64]
-                | [64, 32]
-                | [64, 64]
-                | [32, 32, 32]
-                | [32, 32, 64]
-                | [64, 32, 32]
-                | [32, 32, 32, 32]
-        ))
-    }
-
     fn pack_values_for_register_return<'ctx>(
         &self,
         intrinsics: &Intrinsics<'ctx>,
@@ -502,7 +465,8 @@ impl Abi for Aarch64SystemV {
                     && value.into_float_value().get_type() == intrinsics.f32_ty)
         };
         let is_64 = |value: BasicValueEnum| {
-            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
+            value.is_pointer_value()
+                || (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
                 || (value.is_float_value()
                     && value.into_float_value().get_type() == intrinsics.f64_ty)
         };
@@ -511,56 +475,65 @@ 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 if v.is_pointer_value() {
+                let v =
+                    err!(builder.build_ptr_to_int(v.into_pointer_value(), 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 +546,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 +565,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 +592,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..5bc598150f 100644
--- a/lib/compiler-llvm/src/abi/mod.rs
+++ b/lib/compiler-llvm/src/abi/mod.rs
@@ -5,56 +5,141 @@
 
 #![deny(dead_code, missing_docs)]
 
-use crate::translator::intrinsics::Intrinsics;
+use crate::error::err;
+use crate::translator::intrinsics::{Intrinsics, type_to_llvm};
+use inkwell::values::BasicValue;
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     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;
+use wasmer_types::{CompileError, FunctionType as FuncSig, Type};
 use wasmer_vm::VMOffsets;
 
 mod aarch64_systemv;
+mod riscv_systemv;
 mod x86_64_systemv;
 
 use aarch64_systemv::Aarch64SystemV;
+use riscv_systemv::RiscvSystemV;
 use x86_64_systemv::X86_64SystemV;
 
 pub fn get_abi(target_machine: &TargetMachine) -> Box<dyn Abi> {
-    if target_machine
-        .get_triple()
-        .as_str()
-        .to_string_lossy()
-        .starts_with("aarch64")
-    {
+    let target_name = target_machine.get_triple();
+    let target_name = target_name.as_str().to_string_lossy();
+
+    if target_name.starts_with("aarch64") {
         Box::new(Aarch64SystemV {})
+    } else if target_name.starts_with("riscv") {
+        Box::new(RiscvSystemV {
+            is_riscv64: target_name.starts_with("riscv64"),
+        })
     } else {
         Box::new(X86_64SystemV {})
     }
 }
 
+#[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
 /// targets.
 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>;
+    fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
+        let param = func_value
+            .get_nth_param(u32::from(
+                func_value
+                    .get_enum_attribute(
+                        AttributeLoc::Param(0),
+                        Attribute::get_named_enum_kind_id("sret"),
+                    )
+                    .is_some(),
+            ))
+            .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.
+    #[allow(unused)]
+    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.
+    ///
+    /// # Notes
+    /// This function assumes that g0m0 is enabled.
+    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.
+    ///
+    /// # 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 +148,42 @@ pub trait Abi {
         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
+                .results()
+                .iter()
+                .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                .collect();
+            let llvm_params = llvm_fn_ty
+                .get_context()
+                .struct_type(llvm_params.as_slice(), false);
+            Some(err!(alloca_builder.build_alloca(llvm_params, "sret")))
+        } else {
+            None
+        };
+
+        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());
+
+        let ret = if let Some(sret) = sret {
+            std::iter::once(sret.as_basic_value_enum())
+                .chain(args)
+                .collect()
+        } else {
+            args.collect()
+        };
+
+        Ok(ret)
+    }
 
     /// Given a CallSite, extract the returned values and return them in a Vec.
     fn rets_from_call<'ctx>(
@@ -72,10 +192,34 @@ 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>;
+    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError> {
+        let func_sig_returns_bitwidths = func_sig
+            .results()
+            .iter()
+            .map(|ty| match ty {
+                Type::I32 | Type::F32 | Type::ExceptionRef => 32,
+                Type::I64 | Type::F64 => 64,
+                Type::V128 => 128,
+                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+            })
+            .collect::<Vec<i32>>();
+
+        Ok(!matches!(
+            func_sig_returns_bitwidths.as_slice(),
+            [] | [_]
+                | [32, 32]
+                | [32, 64]
+                | [64, 32]
+                | [64, 64]
+                | [32, 32, 32]
+                | [32, 32, 64]
+                | [64, 32, 32]
+                | [32, 32, 32, 32]
+        ))
+    }
 
     /// Pack LLVM IR values representing individual wasm values into the return type for the function.
     fn pack_values_for_register_return<'ctx>(
diff --git a/lib/compiler-llvm/src/abi/riscv_systemv.rs b/lib/compiler-llvm/src/abi/riscv_systemv.rs
new file mode 100644
index 0000000000..3644fc84c2
--- /dev/null
+++ b/lib/compiler-llvm/src/abi/riscv_systemv.rs
@@ -0,0 +1,654 @@
+use crate::abi::Abi;
+use crate::error::{err, err_nt};
+use crate::translator::intrinsics::{Intrinsics, type_to_llvm};
+use inkwell::{
+    AddressSpace,
+    attributes::{Attribute, AttributeLoc},
+    builder::Builder,
+    context::Context,
+    types::{AnyType, BasicMetadataTypeEnum, BasicType, FunctionType, StructType},
+    values::{BasicValue, BasicValueEnum, CallSiteValue, FloatValue, IntValue, VectorValue},
+};
+use wasmer_types::{CompileError, FunctionType as FuncSig, Type};
+use wasmer_vm::VMOffsets;
+
+use std::convert::TryInto;
+
+use super::G0M0FunctionKind;
+
+/// Implementation of the [`Abi`] trait for the RISC-V SystemV ABI.
+pub(crate) struct RiscvSystemV {
+    pub(crate) is_riscv64: bool,
+}
+
+impl Abi for RiscvSystemV {
+    // Given a wasm function type, produce an llvm function declaration.
+    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> {
+        let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
+
+        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 mut extra_params = param_types.len();
+        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| {
+            vec![
+                (
+                    context.create_enum_attribute(Attribute::get_named_enum_kind_id("nofree"), 0),
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    if let Some(offsets) = offsets {
+                        context.create_enum_attribute(
+                            Attribute::get_named_enum_kind_id("dereferenceable"),
+                            offsets.size_of_vmctx().into(),
+                        )
+                    } else {
+                        context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("nonnull"), 0)
+                    },
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    context.create_enum_attribute(
+                        Attribute::get_named_enum_kind_id("align"),
+                        std::mem::align_of::<wasmer_vm::VMContext>()
+                            .try_into()
+                            .unwrap(),
+                    ),
+                    AttributeLoc::Param(i),
+                ),
+            ]
+        };
+
+        let sig_returns_bitwidths = sig
+            .results()
+            .iter()
+            .map(|ty| match ty {
+                Type::I32 | Type::F32 | Type::ExceptionRef => 32,
+                Type::I64 | Type::F64 => 64,
+                Type::V128 => 128,
+                Type::ExternRef | Type::FuncRef => {
+                    if self.is_riscv64 {
+                        64
+                    } else {
+                        32
+                    }
+                } /* pointer */
+            })
+            .collect::<Vec<i32>>();
+
+        let (fn_type, mut attributes) = match sig_returns_bitwidths.as_slice() {
+            [] => (
+                intrinsics.void_ty.fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [_] => {
+                let single_value = sig.results()[0];
+                (
+                    type_to_llvm(intrinsics, single_value)?.fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 64] | [64, 32] | [64, 64] => {
+                let basic_types: Vec<_> = sig
+                    .results()
+                    .iter()
+                    .map(|&ty| type_to_llvm(intrinsics, ty))
+                    .collect::<Result<_, _>>()?;
+
+                (
+                    context.struct_type(&basic_types, false).fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 32] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => (
+                intrinsics.f32_ty.vec_type(2).fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [32, 32] => (
+                intrinsics.i64_ty.fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [32, 32, 32 | 64] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => {
+                (
+                    context
+                        .struct_type(
+                            &[
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum(),
+                                type_to_llvm(intrinsics, sig.results()[2])?,
+                            ],
+                            false,
+                        )
+                        .fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 32, 32 | 64] => (
+                context
+                    .struct_type(
+                        &[
+                            intrinsics.i64_ty.as_basic_type_enum(),
+                            type_to_llvm(intrinsics, sig.results()[2])?,
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            [64, 32, 32] if sig.results()[1] == Type::F32 && sig.results()[2] == Type::F32 => (
+                context
+                    .struct_type(
+                        &[
+                            type_to_llvm(intrinsics, sig.results()[0])?,
+                            intrinsics.f32_ty.vec_type(2).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),
+            ),
+            [64, 32, 32] => (
+                context
+                    .struct_type(
+                        &[
+                            type_to_llvm(intrinsics, sig.results()[0])?,
+                            intrinsics.i64_ty.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),
+            ),
+            [32, 32, 32, 32] => (
+                context
+                    .struct_type(
+                        &[
+                            if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 {
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                            } else {
+                                intrinsics.i64_ty.as_basic_type_enum()
+                            },
+                            if sig.results()[2] == Type::F32 && sig.results()[3] == Type::F32 {
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                            } else {
+                                intrinsics.i64_ty.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 basic_types: Vec<_> = sig
+                    .results()
+                    .iter()
+                    .map(|&ty| type_to_llvm(intrinsics, ty))
+                    .collect::<Result<_, _>>()?;
+
+                let sret = context.struct_type(&basic_types, false);
+                let sret_ptr = context.ptr_type(AddressSpace::default());
+
+                let param_types =
+                    std::iter::once(Ok(sret_ptr.as_basic_type_enum())).chain(param_types);
+                extra_params += 1;
+
+                let mut attributes = vec![(
+                    context.create_type_attribute(
+                        Attribute::get_named_enum_kind_id("sret"),
+                        sret.as_any_type_enum(),
+                    ),
+                    AttributeLoc::Param(0),
+                )];
+                attributes.append(&mut vmctx_attributes(1));
+
+                (
+                    intrinsics.void_ty.fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    attributes,
+                )
+            }
+        };
+
+        // https://five-embeddev.com/riscv-user-isa-manual/Priv-v1.12/rv64.html
+        // > The compiler and calling convention maintain an invariant that all 32-bit values are held in a sign-extended format in 64-bit registers.
+        // > Even 32-bit unsigned integers extend bit 31 into bits 63 through 32. Consequently, conversion between unsigned and signed 32-bit integers
+        // > is a no-op, as is conversion from a signed 32-bit integer to a signed 64-bit integer.
+        if self.is_riscv64 {
+            for (i, ty) in sig.params().iter().enumerate() {
+                let i = (i + extra_params) as u32;
+                if matches!(ty, Type::I32) {
+                    attributes.push((
+                        context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("signext"), 0),
+                        AttributeLoc::Param(i),
+                    ));
+                    attributes.push((
+                        context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("noundef"), 0),
+                        AttributeLoc::Param(i),
+                    ));
+                }
+            }
+        }
+
+        Ok((fn_type, attributes))
+    }
+
+    // Given a CallSite, extract the returned values and return them in a Vec.
+    fn rets_from_call<'ctx>(
+        &self,
+        builder: &Builder<'ctx>,
+        intrinsics: &Intrinsics<'ctx>,
+        call_site: CallSiteValue<'ctx>,
+        func_sig: &FuncSig,
+    ) -> 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>| -> Result<(FloatValue<'ctx>, FloatValue<'ctx>), CompileError> {
+            assert!(value.get_type() == f32x2_ty.into_vector_type());
+            let ret0 = err!(builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(0, false), ""))
+                .into_float_value();
+            let ret1 = err!(builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(1, false), ""))
+                .into_float_value();
+            Ok((ret0, ret1))
+        };
+
+        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"),
+                }
+            };
+
+        if let Some(basic_value) = call_site.try_as_basic_value().basic() {
+            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 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 Ok(vec![ret0.into(), ret1.into()]);
+                }
+                let struct_value = basic_value.into_struct_value();
+                let rets = (0..struct_value.get_type().count_fields())
+                    .map(|i| builder.build_extract_value(struct_value, i, "").unwrap())
+                    .collect::<Vec<_>>();
+                let func_sig_returns_bitwidths = func_sig
+                    .results()
+                    .iter()
+                    .map(|ty| match ty {
+                        Type::I32 | Type::F32 | Type::ExceptionRef => 32,
+                        Type::I64 | Type::F64 => 64,
+                        Type::V128 => 128,
+                        Type::ExternRef | Type::FuncRef => {
+                            if self.is_riscv64 {
+                                64
+                            } else {
+                                32
+                            }
+                        } /* pointer */
+                    })
+                    .collect::<Vec<i32>>();
+
+                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]]
+                    }
+                    [32, 32, _]
+                        if rets[0].get_type()
+                            == 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())?;
+                        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])?;
+                        vec![low, high, rets[1]]
+                    }
+                    [64, 32, 32]
+                        if rets[1].get_type()
+                            == 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())?;
+                        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])?;
+                        vec![rets[0], rets1, rets2]
+                    }
+                    [32, 32, 32, 32] => {
+                        assert!(func_sig.results().len() == 4);
+                        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())?;
+                            (x.into(), y.into())
+                        } else {
+                            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())?;
+                            (x.into(), y.into())
+                        } else {
+                            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])?;
+                        vec![low0, high0, low1, high1]
+                    }
+                    _ => unreachable!("expected an sret for this type"),
+                };
+
+                Ok(ret)
+            } else {
+                assert!(func_sig.results().len() == 1);
+                Ok(vec![basic_value])
+            }
+        } else {
+            assert!(call_site.count_arguments() > 0); // Either sret or vmctx.
+            if call_site
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some()
+            {
+                let sret_ty = call_site
+                    .try_as_basic_value()
+                    .unwrap_instruction()
+                    .get_operand(0)
+                    .unwrap()
+                    .unwrap_value();
+                let sret = sret_ty.into_pointer_value();
+                // re-build the llvm-type struct holding the return values
+                let llvm_results: Vec<_> = func_sig
+                    .results()
+                    .iter()
+                    .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                    .collect();
+                let struct_type = intrinsics
+                    .i32_ty
+                    .get_context()
+                    .struct_type(llvm_results.as_slice(), false);
+
+                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());
+                Ok(rets)
+            } else {
+                assert!(func_sig.results().is_empty());
+                Ok(vec![])
+            }
+        }
+    }
+
+    fn pack_values_for_register_return<'ctx>(
+        &self,
+        intrinsics: &Intrinsics<'ctx>,
+        builder: &Builder<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        func_type: &FunctionType<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
+        let is_32 = |value: BasicValueEnum| {
+            (value.is_pointer_value() && !self.is_riscv64)
+                || (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i32_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f32_ty)
+        };
+        let is_64 = |value: BasicValueEnum| {
+            (value.is_pointer_value() && self.is_riscv64)
+                || (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f64_ty)
+        };
+        let is_f32 = |value: BasicValueEnum| {
+            value.is_float_value() && value.into_float_value().get_type() == intrinsics.f32_ty
+        };
+
+        let pack_i32s = |low: BasicValueEnum<'ctx>, high: BasicValueEnum<'ctx>| {
+            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 = 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>|
+         -> 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 = 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), "")
+                    .map(|v| v.as_basic_value_enum())
+            )
+        };
+
+        let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
+            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()
+                    .into_struct_value();
+            }
+            struct_value.as_basic_value_enum()
+        };
+
+        Ok(match *values {
+            [one_value] => one_value,
+            [v1, v2] if is_f32(v1) && is_f32(v2) => pack_f32s(v1, v2)?,
+            [v1, v2] if is_32(v1) && is_32(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)));
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, v2],
+                )
+            }
+            [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],
+            ),
+            [v1, v2, v3] if is_32(v1) && is_32(v2) => {
+                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],
+                )
+            }
+            [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, v2, v3] if is_64(v1) && is_32(v2) && is_32(v3) => {
+                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, 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)?
+                } else {
+                    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)?
+                } else {
+                    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(),
+                    &[v1v2_pack, v3v4_pack],
+                )
+            }
+            _ => {
+                unreachable!("called to perform register return on struct return or void function")
+            }
+        })
+    }
+}
diff --git a/lib/compiler-llvm/src/abi/x86_64_systemv.rs b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
index 47f1f75d16..cc6424cdff 100644
--- a/lib/compiler-llvm/src/abi/x86_64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
@@ -1,40 +1,26 @@
 use crate::abi::Abi;
-use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+use crate::error::{err, err_nt};
+use crate::translator::intrinsics::{Intrinsics, type_to_llvm};
+use inkwell::values::BasicValue;
 use inkwell::{
+    AddressSpace,
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     context::Context,
     types::{AnyType, BasicMetadataTypeEnum, BasicType, FunctionType, StructType},
-    values::{
-        BasicValue, BasicValueEnum, CallSiteValue, FloatValue, FunctionValue, IntValue,
-        PointerValue, VectorValue,
-    },
-    AddressSpace,
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, VectorValue},
 };
 use wasmer_types::{CompileError, FunctionType as FuncSig, Type};
 use wasmer_vm::VMOffsets;
 
 use std::convert::TryInto;
 
+use super::G0M0FunctionKind;
+
 /// 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.
-    fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
-        func_value
-            .get_nth_param(u32::from(
-                func_value
-                    .get_enum_attribute(
-                        AttributeLoc::Param(0),
-                        Attribute::get_named_enum_kind_id("sret"),
-                    )
-                    .is_some(),
-            ))
-            .unwrap()
-            .into_pointer_value()
-    }
-
     // Given a wasm function type, produce an llvm function declaration.
     fn func_type_to_llvm<'ctx>(
         &self,
@@ -42,11 +28,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| {
@@ -83,7 +77,7 @@ impl Abi for X86_64SystemV {
             .results()
             .iter()
             .map(|ty| match ty {
-                Type::I32 | Type::F32 => 32,
+                Type::I32 | Type::F32 | Type::ExceptionRef => 32,
                 Type::I64 | Type::F64 => 64,
                 Type::V128 => 128,
                 Type::ExternRef | Type::FuncRef => 64, /* pointer */
@@ -152,25 +146,27 @@ impl Abi for X86_64SystemV {
                 ),
                 vmctx_attributes(0),
             ),
-            [32, 32, _] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => (
-                context
-                    .struct_type(
-                        &[
-                            intrinsics.f32_ty.vec_type(2).as_basic_type_enum(),
-                            type_to_llvm(intrinsics, sig.results()[2])?,
-                        ],
-                        false,
-                    )
-                    .fn_type(
-                        param_types
-                            .map(|v| v.map(Into::into))
-                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
-                            .as_slice(),
-                        false,
-                    ),
-                vmctx_attributes(0),
-            ),
-            [32, 32, _] => (
+            [32, 32, 32 | 64] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => {
+                (
+                    context
+                        .struct_type(
+                            &[
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum(),
+                                type_to_llvm(intrinsics, sig.results()[2])?,
+                            ],
+                            false,
+                        )
+                        .fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 32, 32 | 64] => (
                 context
                     .struct_type(
                         &[
@@ -258,7 +254,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);
@@ -286,42 +282,6 @@ impl Abi for X86_64SystemV {
         })
     }
 
-    // Marshall wasm stack values into function parameters.
-    fn args_to_call<'ctx>(
-        &self,
-        alloca_builder: &Builder<'ctx>,
-        func_sig: &FuncSig,
-        llvm_fn_ty: &FunctionType<'ctx>,
-        ctx_ptr: PointerValue<'ctx>,
-        values: &[BasicValueEnum<'ctx>],
-        intrinsics: &Intrinsics<'ctx>,
-    ) -> Vec<BasicValueEnum<'ctx>> {
-        // 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
-                .results()
-                .iter()
-                .map(|x| type_to_llvm(intrinsics, *x).unwrap())
-                .collect();
-            let llvm_params = llvm_fn_ty
-                .get_context()
-                .struct_type(llvm_params.as_slice(), false);
-            Some(alloca_builder.build_alloca(llvm_params, "sret"))
-        } else {
-            None
-        };
-
-        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
-
-        if let Some(sret) = sret {
-            std::iter::once(sret.as_basic_value_enum())
-                .chain(values)
-                .collect()
-        } else {
-            values.collect()
-        }
-    }
-
     // Given a CallSite, extract the returned values and return them in a Vec.
     fn rets_from_call<'ctx>(
         &self,
@@ -329,62 +289,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 | Type::ExceptionRef => {
+                        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 let Some(basic_value) = call_site.try_as_basic_value().basic() {
             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())
@@ -394,14 +360,14 @@ impl Abi for X86_64SystemV {
                     .results()
                     .iter()
                     .map(|ty| match ty {
-                        Type::I32 | Type::F32 => 32,
+                        Type::I32 | Type::F32 | Type::ExceptionRef => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
                         Type::ExternRef | Type::FuncRef => 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 +377,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 +392,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 +407,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.
@@ -479,12 +447,10 @@ impl Abi for X86_64SystemV {
             {
                 let sret_ty = call_site
                     .try_as_basic_value()
-                    .right()
-                    .unwrap()
+                    .unwrap_instruction()
                     .get_operand(0)
                     .unwrap()
-                    .left()
-                    .unwrap();
+                    .unwrap_value();
                 let sret = sret_ty.into_pointer_value();
                 // re-build the llvm-type struct holding the return values
                 let llvm_results: Vec<_> = func_sig
@@ -497,49 +463,22 @@ 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![])
             }
         }
     }
 
-    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError> {
-        let func_sig_returns_bitwidths = func_sig
-            .results()
-            .iter()
-            .map(|ty| match ty {
-                Type::I32 | Type::F32 => 32,
-                Type::I64 | Type::F64 => 64,
-                Type::V128 => 128,
-                Type::ExternRef | Type::FuncRef => 64, /* pointer */
-            })
-            .collect::<Vec<i32>>();
-
-        Ok(!matches!(
-            func_sig_returns_bitwidths.as_slice(),
-            [] | [_]
-                | [32, 32]
-                | [32, 64]
-                | [64, 32]
-                | [64, 64]
-                | [32, 32, 32]
-                | [32, 32, 64]
-                | [64, 32, 32]
-                | [32, 32, 32, 32]
-        ))
-    }
-
     fn pack_values_for_register_return<'ctx>(
         &self,
         intrinsics: &Intrinsics<'ctx>,
@@ -553,7 +492,8 @@ impl Abi for X86_64SystemV {
                     && value.into_float_value().get_type() == intrinsics.f32_ty)
         };
         let is_64 = |value: BasicValueEnum| {
-            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
+            value.is_pointer_value()
+                || (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
                 || (value.is_float_value()
                     && value.into_float_value().get_type() == intrinsics.f64_ty)
         };
@@ -565,24 +505,35 @@ 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
-                .build_insert_element(vec, second, intrinsics.i32_ty.const_int(1, false), "")
-                .as_basic_value_enum()
+            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), "")
+                    .map(|v| v.as_basic_value_enum())
+            )
         };
 
         let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
@@ -598,11 +549,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 +564,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..90a1e0eb16 100644
--- a/lib/compiler-llvm/src/compiler.rs
+++ b/lib/compiler-llvm/src/compiler.rs
@@ -1,27 +1,43 @@
 use crate::config::LLVM;
 use crate::trampoline::FuncTrampoline;
 use crate::translator::FuncTranslator;
-use crate::CompiledKind;
+use inkwell::DLLStorageClass;
 use inkwell::context::Context;
 use inkwell::memory_buffer::MemoryBuffer;
 use inkwell::module::{Linkage, Module};
 use inkwell::targets::FileType;
-use inkwell::DLLStorageClass;
+use rayon::ThreadPoolBuilder;
 use rayon::iter::ParallelBridge;
 use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
-use std::sync::Arc;
-use wasmer_compiler::{Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState};
+use std::{
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+use wasmer_compiler::misc::CompiledKind;
+use wasmer_compiler::progress::ProgressContext;
+use wasmer_compiler::types::function::{Compilation, UnwindInfo};
+use wasmer_compiler::types::module::CompileModuleInfo;
+use wasmer_compiler::types::relocation::RelocationKind;
+use wasmer_compiler::{
+    Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState,
+    types::{
+        relocation::RelocationTarget,
+        section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
+        symbols::{Symbol, SymbolRegistry},
+    },
+};
 use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::Target;
 use wasmer_types::{
-    Compilation, CompileError, CompileModuleInfo, CustomSection, CustomSectionProtection, Dwarf,
-    FunctionIndex, LocalFunctionIndex, RelocationTarget, SectionBody, SectionIndex, SignatureIndex,
-    Symbol, SymbolRegistry, Target,
+    CompilationProgressCallback, CompileError, FunctionIndex, LocalFunctionIndex, ModuleInfo,
+    SignatureIndex,
 };
-
-//use std::sync::Mutex;
+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 +91,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 +178,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 +188,16 @@ 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)
+                let target_machine_no_opt = self.config().target_machine_with_opt(target, false);
+                let pointer_width = target.triple().pointer_width().unwrap().bytes();
+                FuncTranslator::new(
+                    target.triple().clone(),
+                    target_machine,
+                    Some(target_machine_no_opt),
+                    binary_format,
+                    pointer_width,
+                )
+                .unwrap()
             },
             |func_translator, (i, input)| {
                 let module = func_translator.translate_to_module(
@@ -105,7 +209,9 @@ impl LLVMCompiler {
                     &compile_info.memory_styles,
                     &compile_info.table_styles,
                     symbol_registry,
+                    target.triple(),
                 )?;
+
                 Ok(module.write_bitcode_to_memory().as_slice().to_vec())
             },
         );
@@ -113,29 +219,40 @@ 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, target.triple().clone(), 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())
             },
         );
 
+        let module_hash = compile_info.module.hash_string();
         let dynamic_trampolines_bitcode =
             compile_info.module.functions.iter().par_bridge().map_init(
                 || {
                     let target_machine = self.config().target_machine(target);
                     (
-                        FuncTrampoline::new(target_machine),
+                        FuncTrampoline::new(target_machine, target.triple().clone(), binary_format)
+                            .unwrap(),
                         &compile_info.module.signatures,
                     )
                 },
                 |(func_trampoline, signatures), (i, sig)| {
                     let sig = &signatures[*sig];
                     let name = symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(i));
-                    let module =
-                        func_trampoline.dynamic_trampoline_to_module(sig, self.config(), &name)?;
+                    let module = func_trampoline.dynamic_trampoline_to_module(
+                        sig,
+                        self.config(),
+                        &name,
+                        &module_hash,
+                    )?;
                     Ok(module.write_bitcode_to_memory().as_slice().to_vec())
                 },
             );
@@ -172,7 +289,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);
@@ -187,9 +304,14 @@ impl LLVMCompiler {
             .write_to_memory_buffer(&merged_module, FileType::Object)
             .unwrap();
         if let Some(ref callbacks) = self.config.callbacks {
-            callbacks.obj_memory_buffer(&CompiledKind::Module, &memory_buffer);
+            callbacks.obj_memory_buffer(
+                &CompiledKind::Module,
+                &compile_info.module.hash_string(),
+                &memory_buffer,
+            );
         }
 
+        tracing::trace!("Finished compling the module!");
         Ok(memory_buffer.as_slice().to_vec())
     }
 }
@@ -199,6 +321,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 +366,7 @@ impl Compiler for LLVMCompiler {
             function_body_inputs,
             symbol_registry,
             wasmer_metadata,
+            self.config.target_binary_format(target),
         ))
     }
 
@@ -233,43 +378,98 @@ impl Compiler for LLVMCompiler {
         compile_info: &CompileModuleInfo,
         module_translation: &ModuleTranslationState,
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
     ) -> 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;
+        let module_hash = module.hash_string();
+        let total_functions = function_body_inputs.len() as u64;
+        let total_function_call_trampolines = module.signatures.len() as u64;
+        let total_dynamic_trampolines = module.num_imported_functions as u64;
+        let total_steps =
+            total_functions + total_function_call_trampolines + total_dynamic_trampolines;
+        let progress = progress_callback
+            .cloned()
+            .map(|cb| ProgressContext::new(cb, total_steps, "Compiling functions"));
 
         // 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)| {
-                    // TODO: remove (to serialize)
-                    //let _data = data.lock().unwrap();
-                    func_translator.translate(
-                        module,
-                        module_translation,
-                        i,
-                        input,
-                        self.config(),
-                        memory_styles,
-                        table_styles,
-                        &ShortNames {},
-                    )
-                },
-            )
-            .collect::<Result<Vec<_>, CompileError>>()?
+
+        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 progress = progress.clone();
+        let pool = ThreadPoolBuilder::new()
+            .num_threads(self.config.num_threads.get())
+            .build()
+            .map_err(|e| CompileError::Resource(e.to_string()))?;
+        let functions = pool.install(|| {
+            function_body_inputs
+                .iter()
+                .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+                .par_iter()
+                .map_init(
+                    || {
+                        let target_machine = self.config().target_machine_with_opt(target, true);
+                        let target_machine_no_opt =
+                            self.config().target_machine_with_opt(target, false);
+                        let pointer_width = target.triple().pointer_width().unwrap().bytes();
+                        FuncTranslator::new(
+                            target.triple().clone(),
+                            target_machine,
+                            Some(target_machine_no_opt),
+                            binary_format,
+                            pointer_width,
+                        )
+                        .unwrap()
+                    },
+                    |func_translator, (i, input)| {
+                        // TODO: remove (to serialize)
+                        //let _data = data.lock().unwrap();
+
+                        let translated = func_translator.translate(
+                            module,
+                            module_translation,
+                            i,
+                            input,
+                            self.config(),
+                            memory_styles,
+                            table_styles,
+                            &symbol_registry,
+                            target.triple(),
+                        );
+
+                        if let Some(progress) = progress.as_ref() {
+                            progress.notify()?;
+                        }
+
+                        translated
+                    },
+                )
+                .collect::<Result<Vec<_>, CompileError>>()
+        })?;
+
+        let functions = functions
             .into_iter()
             .map(|mut compiled_function| {
                 let first_section = module_custom_sections.len() as u32;
@@ -282,20 +482,46 @@ 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;
                         }
-                        frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
-                        frame_section_relocations.extend(custom_section.relocations);
+                        eh_frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
+                        // Terminate the eh_frame info with a zero-length CIE.
+                        eh_frame_section_bytes.extend_from_slice(&[0, 0, 0, 0]);
+                        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;
+                        }
+                        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 +535,164 @@ 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 progress = progress.clone();
+        let function_call_trampolines = pool.install(|| {
+            module
+                .signatures
+                .values()
+                .collect::<Vec<_>>()
+                .par_iter()
+                .map_init(
+                    || {
+                        let target_machine = self.config().target_machine(target);
+                        FuncTrampoline::new(target_machine, target.triple().clone(), binary_format)
+                            .unwrap()
+                    },
+                    |func_trampoline, sig| {
+                        let trampoline =
+                            func_trampoline.trampoline(sig, self.config(), "", compile_info);
+                        if let Some(progress) = progress.as_ref() {
+                            progress.notify()?;
+                        }
+                        trampoline
+                    },
+                )
+                .collect::<Vec<_>>()
+                .into_iter()
+                .collect::<Result<PrimaryMap<_, _>, CompileError>>()
+        })?;
+
+        // TODO: I removed the parallel processing of dynamic trampolines because we're passing
+        // the sections bytes and relocations directly into the trampoline generation function.
+        // We can move that logic out and re-enable parallel processing. Hopefully, there aren't
+        // enough dynamic trampolines to actually cause a noticeable performance degradation.
+        let dynamic_function_trampolines = {
+            let progress = progress.clone();
+            let target_machine = self.config().target_machine(target);
+            let func_trampoline =
+                FuncTrampoline::new(target_machine, target.triple().clone(), binary_format)
+                    .unwrap();
+            module
+                .imported_function_types()
+                .collect::<Vec<_>>()
+                .into_iter()
+                .enumerate()
+                .map(|(index, func_type)| {
+                    let trampoline = func_trampoline.dynamic_trampoline(
+                        &func_type,
+                        self.config(),
+                        "",
+                        index as u32,
+                        &mut module_custom_sections,
+                        &mut eh_frame_section_bytes,
+                        &mut eh_frame_section_relocations,
+                        &mut compact_unwind_section_bytes,
+                        &mut compact_unwind_section_relocations,
+                        &module_hash,
+                    )?;
+                    if let Some(progress) = progress.as_ref() {
+                        progress.notify()?;
+                    }
+                    Ok(trampoline)
+                })
+                .collect::<Vec<_>>()
+                .into_iter()
+                .collect::<Result<PrimaryMap<_, _>, CompileError>>()?
+        };
+
+        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);
             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
-        } else {
-            None
-        };
+            unwind_info.eh_frame = Some(eh_frame_idx);
+        }
 
-        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>>()?;
+        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 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..9053413592 100644
--- a/lib/compiler-llvm/src/config.rs
+++ b/lib/compiler-llvm/src/config.rs
@@ -1,15 +1,22 @@
 use crate::compiler::LLVMCompiler;
+pub use inkwell::OptimizationLevel as LLVMOptLevel;
 use inkwell::targets::{
     CodeModel, InitializationConfig, RelocMode, Target as InkwellTarget, TargetMachine,
-    TargetTriple,
+    TargetMachineOptions, TargetTriple,
 };
-pub use inkwell::OptimizationLevel as LLVMOptLevel;
 use itertools::Itertools;
-use std::fmt::Debug;
+use std::fs::File;
+use std::io::{self, Write};
+use std::path::PathBuf;
 use std::sync::Arc;
-use target_lexicon::Architecture;
+use std::{fmt::Debug, num::NonZero};
+use target_lexicon::BinaryFormat;
+use wasmer_compiler::misc::{CompiledKind, function_kind_to_filename};
 use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{FunctionType, LocalFunctionIndex, Target, Triple};
+use wasmer_types::{
+    Features,
+    target::{Architecture, OperatingSystem, Target, Triple},
+};
 
 /// The InkWell ModuleInfo type
 pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;
@@ -17,35 +24,96 @@ pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;
 /// The InkWell MemoryBuffer type
 pub type InkwellMemoryBuffer = inkwell::memory_buffer::MemoryBuffer;
 
-/// The compiled function kind, used for debugging in the `LLVMCallbacks`.
+/// Callbacks to the different LLVM compilation phases.
 #[derive(Debug, Clone)]
-pub enum CompiledKind {
-    // A locally-defined function in the Wasm file.
-    Local(LocalFunctionIndex),
-    // A function call trampoline for a given signature.
-    FunctionCallTrampoline(FunctionType),
-    // A dynamic function trampoline for a given signature.
-    DynamicFunctionTrampoline(FunctionType),
-    // An entire Wasm module.
-    Module,
+pub struct LLVMCallbacks {
+    debug_dir: PathBuf,
 }
 
-/// Callbacks to the different LLVM compilation phases.
-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);
+impl LLVMCallbacks {
+    pub fn new(debug_dir: PathBuf) -> Result<Self, io::Error> {
+        // Create the debug dir in case it doesn't exist
+        std::fs::create_dir_all(&debug_dir)?;
+        Ok(Self { debug_dir })
+    }
+
+    fn base_path(&self, module_hash: &Option<String>) -> PathBuf {
+        let mut path = self.debug_dir.clone();
+        if let Some(hash) = module_hash {
+            path.push(hash);
+        }
+        std::fs::create_dir_all(&path)
+            .unwrap_or_else(|_| panic!("cannot create debug directory: {}", path.display()));
+        path
+    }
+
+    pub fn preopt_ir(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        module: &InkwellModule,
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".preopt.ll"));
+        module
+            .print_to_file(&path)
+            .expect("Error while dumping pre optimized LLVM IR");
+    }
+    pub fn postopt_ir(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        module: &InkwellModule,
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".postopt.ll"));
+        module
+            .print_to_file(&path)
+            .expect("Error while dumping post optimized LLVM IR");
+    }
+    pub fn obj_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        memory_buffer: &InkwellMemoryBuffer,
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".o"));
+        let mem_buf_slice = memory_buffer.as_slice();
+        let mut file =
+            File::create(path).expect("Error while creating debug object file from LLVM IR");
+        file.write_all(mem_buf_slice).unwrap();
+    }
+
+    pub fn asm_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        asm_memory_buffer: &InkwellMemoryBuffer,
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".s"));
+        let mem_buf_slice = asm_memory_buffer.as_slice();
+        let mut file =
+            File::create(path).expect("Error while creating debug assembly file from LLVM IR");
+        file.write_all(mem_buf_slice).unwrap();
+    }
 }
 
 #[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>>,
+    pub(crate) callbacks: Option<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>,
+    pub(crate) verbose_asm: bool,
 }
 
 impl LLVM {
@@ -55,10 +123,14 @@ 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,
+            verbose_asm: false,
+            num_threads: std::thread::available_parallelism().unwrap_or(NonZero::new(1).unwrap()),
         }
     }
 
@@ -68,14 +140,36 @@ 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
+    }
+
+    pub fn verbose_asm(&mut self, verbose_asm: bool) -> &mut Self {
+        self.verbose_asm = verbose_asm;
+        self
+    }
+
     /// Callbacks that will triggered in the different compilation
     /// phases in LLVM.
-    pub fn callbacks(&mut self, callbacks: Option<Arc<dyn LLVMCallbacks>>) -> &mut Self {
+    pub fn callbacks(&mut self, callbacks: Option<LLVMCallbacks>) -> &mut Self {
         self.callbacks = callbacks;
         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 +177,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,6 +194,37 @@ impl LLVM {
         }
     }
 
+    pub(crate) fn target_operating_system(&self, target: &Target) -> OperatingSystem {
+        match target.triple().operating_system {
+            OperatingSystem::Darwin(deployment) if !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
+                // MachO, they check whether the OS is set to Darwin.
+                //
+                // Since both linux and darwin use SysV ABI, this should work.
+                //  but not in the case of Aarch64, there the ABI is slightly different
+                #[allow(clippy::match_single_binding)]
+                match target.triple().architecture {
+                    Architecture::Aarch64(_) => OperatingSystem::Darwin(deployment),
+                    _ => OperatingSystem::Linux,
+                }
+            }
+            other => other,
+        }
+    }
+
+    pub(crate) fn target_binary_format(&self, target: &Target) -> target_lexicon::BinaryFormat {
+        if self.is_pic {
+            target.triple().binary_format
+        } else {
+            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)
@@ -106,29 +235,10 @@ impl LLVM {
         };
         // 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
-        {
-            // 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
-            // MachO, they check whether the OS is set to Darwin.
-            //
-            // Since both linux and darwin use SysV ABI, this should work.
-            //  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,
-            }
-        } else {
-            target.triple().operating_system
-        };
-        let binary_format = if self.is_pic {
-            target.triple().binary_format
-        } else {
-            target_lexicon::BinaryFormat::Elf
-        };
+
+        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(),
@@ -141,6 +251,14 @@ impl LLVM {
 
     /// Generates the target machine for the current target
     pub fn target_machine(&self, target: &Target) -> TargetMachine {
+        self.target_machine_with_opt(target, true)
+    }
+
+    pub(crate) fn target_machine_with_opt(
+        &self,
+        target: &Target,
+        enable_optimization: bool,
+    ) -> TargetMachine {
         let triple = target.triple();
         let cpu_features = &target.cpu_features();
 
@@ -163,22 +281,26 @@ impl LLVM {
                 info: true,
                 machine_code: true,
             }),
-            Architecture::Riscv64(_) => InkwellTarget::initialize_riscv(&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,
-            //     base: true,
-            //     disassembler: true,
-            //     info: true,
-            //     machine_code: true,
-            // }),
+            Architecture::Riscv64(_) | Architecture::Riscv32(_) => {
+                InkwellTarget::initialize_riscv(&InitializationConfig {
+                    asm_parser: true,
+                    asm_printer: true,
+                    base: true,
+                    disassembler: true,
+                    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,
+                })
+            }
             _ => unimplemented!("target {} not yet supported in Wasmer", triple),
         }
 
@@ -187,62 +309,44 @@ 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);
         let llvm_target = InkwellTarget::from_triple(&target_triple).unwrap();
-        let llvm_target_machine = llvm_target
-            .create_target_machine(
-                &target_triple,
-                match triple.architecture {
-                    Architecture::Riscv64(_) => "generic-rv64",
-                    _ => "generic",
-                },
-                match triple.architecture {
-                    Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
-                    _ => &llvm_cpu_features,
-                },
-                self.opt_level,
-                self.reloc_mode(),
-                match triple.architecture {
-                    Architecture::Riscv64(_) => CodeModel::Medium,
-                    _ => self.code_model(),
-                },
-            )
-            .unwrap();
-
-        if let Architecture::Riscv64(_) = triple.architecture {
-            // TODO: totally non-portable way to change ABI
-            unsafe {
-                // This structure mimic the internal structure from inkwell
-                // that is defined as
-                //  #[derive(Debug)]
-                //  pub struct TargetMachine {
-                //    pub(crate) target_machine: LLVMTargetMachineRef,
-                //  }
-                pub struct MyTargetMachine {
-                    pub target_machine: *const u8,
+        let mut llvm_target_machine_options = TargetMachineOptions::new()
+            .set_cpu(match triple.architecture {
+                Architecture::Riscv64(_) => "generic-rv64",
+                Architecture::Riscv32(_) => "generic-rv32",
+                Architecture::LoongArch64 => "generic-la64",
+                _ => "generic",
+            })
+            .set_features(match triple.architecture {
+                Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
+                Architecture::Riscv32(_) => "+m,+a,+c,+d,+f",
+                Architecture::LoongArch64 => "+f,+d",
+                _ => &llvm_cpu_features,
+            })
+            .set_level(if enable_optimization {
+                self.opt_level
+            } else {
+                LLVMOptLevel::None
+            })
+            .set_reloc_mode(self.reloc_mode(self.target_binary_format(target)))
+            .set_code_model(match triple.architecture {
+                Architecture::LoongArch64 | Architecture::Riscv64(_) | Architecture::Riscv32(_) => {
+                    CodeModel::Medium
                 }
-                // It is use to live patch the create LLVMTargetMachine
-                // to hard change the ABI and force "-mabi=lp64d" ABI
-                // instead of the default that don't use float registers
-                // because there is no current way to do this change
-
-                let my_target_machine: MyTargetMachine = std::mem::transmute(llvm_target_machine);
-
-                *((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),
-                    6,
-                );
-
-                std::mem::transmute(my_target_machine)
-            }
-        } else {
-            llvm_target_machine
+                _ => self.code_model(self.target_binary_format(target)),
+            });
+        if let Architecture::Riscv64(_) = triple.architecture {
+            llvm_target_machine_options = llvm_target_machine_options.set_abi("lp64d");
         }
+        let target_machine = llvm_target
+            .create_target_machine_from_options(&target_triple, llvm_target_machine_options)
+            .unwrap();
+        target_machine.set_asm_verbosity(self.verbose_asm);
+        target_machine
     }
 }
 
@@ -254,6 +358,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 +380,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..30146a52fd
--- /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..6ef214c60c 100644
--- a/lib/compiler-llvm/src/lib.rs
+++ b/lib/compiler-llvm/src/lib.rs
@@ -12,16 +12,15 @@
 )]
 #![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))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod abi;
 mod compiler;
 mod config;
+mod error;
 mod object_file;
 mod trampoline;
 mod translator;
 
 pub use crate::compiler::LLVMCompiler;
-pub use crate::config::{
-    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVMOptLevel, LLVM,
-};
+pub use crate::config::{InkwellMemoryBuffer, InkwellModule, LLVM, LLVMCallbacks, LLVMOptLevel};
diff --git a/lib/compiler-llvm/src/object_file.rs b/lib/compiler-llvm/src/object_file.rs
index de8702b44c..2b314cbc6e 100644
--- a/lib/compiler-llvm/src/object_file.rs
+++ b/lib/compiler-llvm/src/object_file.rs
@@ -1,135 +1,183 @@
 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::{CompileError, SourceLoc, entity::PrimaryMap};
+
+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>,
+    pub gcc_except_table_section_indices: Vec<SectionIndex>,
+    pub data_dw_ref_personality_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,
+    "__chkstk" => LibCall::Probestack,
+    "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_alloc_exception" => LibCall::AllocException,
+    "wasmer_vm_read_exnref" => LibCall::ReadExnRef,
+    "wasmer_vm_exception_into_exnref" => LibCall::LibunwindExceptionIntoExnRef,
+    "wasmer_eh_personality" => LibCall::EHPersonality,
+    "wasmer_eh_personality2" => LibCall::EHPersonality2,
+    "wasmer_vm_dbg_usize" => LibCall::DebugUsize,
+    "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_alloc_exception" => LibCall::AllocException,
+    "_wasmer_vm_read_exnref" => LibCall::ReadExnRef,
+    "_wasmer_vm_exception_into_exnref" => LibCall::LibunwindExceptionIntoExnRef,
+    // 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_usize" => LibCall::DebugUsize,
+    "_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 mut visited: HashSet<object::read::SectionIndex> = HashSet::new();
+    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 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 +185,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 +201,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
@@ -165,83 +214,68 @@ where
     // it to worklist. `section_to_custom_section` is filled in with all
     // the sections we want to include.
     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();
-            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);
+
+    // Add macos-specific unwind sections.
+    let mut compact_unwind_section_indices = vec![];
+
+    // .gcc_except_table sections, which contain the actual LSDA data.
+    // We don't need the actual sections for anything (yet), but trampoline
+    // codegen checks custom section counts to verify there aren't any
+    // unexpected custom sections, so we do a bit of book-keeping here.
+    let mut gcc_except_table_section_indices = vec![];
+
+    let mut data_dw_ref_personality_section_indices = vec![];
+
+    for section in obj.sections() {
+        let index = section.index();
+        let Ok(section_name) = section.name() else {
+            continue;
+        };
+
+        match section_name {
+            "__eh_frame" | ".eh_frame" => {
+                worklist.push(index);
+                eh_frame_section_indices.push(index);
+
+                // This allocates a custom section index for the ELF section.
+                elf_section_to_target(index);
+            }
+            "__compact_unwind" => {
+                worklist.push(index);
+                compact_unwind_section_indices.push(index);
+
+                elf_section_to_target(index);
+            }
+            ".gcc_except_table" => {
+                worklist.push(index);
+                gcc_except_table_section_indices.push(index);
+
+                elf_section_to_target(index);
+            }
+            ".data.DW.ref.wasmer_eh_personality" => {
+                worklist.push(index);
+                data_dw_ref_personality_section_indices.push(index);
+
+                elf_section_to_target(index);
+            }
+            _ => {}
         }
     }
 
+    let mut visited: HashSet<_> = HashSet::from_iter(worklist.iter().copied());
     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 +291,71 @@ 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.flags(),
+                            object::RelocationFlags::MachO {
+                                r_type: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+                                r_pcrel: false,
+                                ..
+                            } | object::RelocationFlags::MachO {
+                                r_type: object::macho::ARM64_RELOC_POINTER_TO_GOT,
+                                r_pcrel: true,
+                                ..
+                            } | object::RelocationFlags::MachO {
+                                r_type: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
+                                r_pcrel: true,
+                                ..
+                            } | object::RelocationFlags::MachO {
+                                r_type: object::macho::ARM64_RELOC_PAGE21,
+                                r_pcrel: true,
+                                ..
+                            } | object::RelocationFlags::MachO {
+                                r_type: object::macho::ARM64_RELOC_PAGEOFF12,
+                                r_pcrel: 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 +368,7 @@ where
                         }
                     } else {
                         return Err(CompileError::Codegen(format!(
-                            "relocation targets unknown symbol {:?}",
-                            reloc
+                            "relocation {reloc:?} targets unknown symbol '{symbol:?}'",
                         )));
                     }
                 }
@@ -306,8 +389,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 +401,387 @@ 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.flags(), reloc.size()) {
+                (
+                    _,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_X86_64_64,
+                    },
+                    64,
+                ) => RelocationKind::Abs8,
+                (
+                    object::Architecture::X86_64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_X86_64_PC64,
+                    },
+                    0,
+                ) => RelocationKind::PCRel8,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_CALL26,
+                    },
+                    26,
+                ) => RelocationKind::Arm64Call,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G0_NC,
+                    },
+                    0,
+                ) => RelocationKind::Arm64Movw0,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G1_NC,
+                    },
+                    0,
+                ) => RelocationKind::Arm64Movw1,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G2_NC,
+                    },
+                    0,
+                ) => RelocationKind::Arm64Movw2,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G3,
+                    },
+                    0,
+                ) => RelocationKind::Arm64Movw3,
+                (
+                    object::Architecture::Riscv64 | object::Architecture::Riscv32,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_64,
+                    },
+                    64,
+                ) => RelocationKind::Abs8,
+                (
+                    object::Architecture::Riscv64 | object::Architecture::Riscv32,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_CALL_PLT,
+                    },
+                    0,
+                ) => RelocationKind::RiscvCall,
+                (
+                    object::Architecture::Riscv64 | object::Architecture::Riscv32,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_PCREL_HI20,
+                    },
+                    0,
+                ) => RelocationKind::RiscvPCRelHi20,
+                (
+                    object::Architecture::Riscv64 | object::Architecture::Riscv32,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_PCREL_LO12_I,
+                    },
+                    0,
+                ) => RelocationKind::RiscvPCRelLo12I,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_ADD8,
+                    },
+                    0,
+                ) => RelocationKind::Add,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_ADD16,
+                    },
+                    0,
+                ) => RelocationKind::Add2,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_ADD32,
+                    },
+                    0,
+                ) => RelocationKind::Add4,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_ADD64,
+                    },
+                    0,
+                ) => RelocationKind::Add8,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SUB6,
+                    },
+                    0,
+                ) => RelocationKind::Sub6Bits,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SUB8,
+                    },
+                    0,
+                ) => RelocationKind::Sub,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SUB16,
+                    },
+                    0,
+                ) => RelocationKind::Sub2,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SUB32,
+                    },
+                    0,
+                ) => RelocationKind::Sub4,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SUB64,
+                    },
+                    0,
+                ) => RelocationKind::Sub8,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SET6,
+                    },
+                    0,
+                ) => RelocationKind::Abs6Bits,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SET8,
+                    },
+                    0,
+                ) => RelocationKind::Abs,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SET16,
+                    },
+                    0,
+                ) => RelocationKind::Abs2,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_SET32,
+                    },
+                    0,
+                ) => RelocationKind::Abs4,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_32,
+                    },
+                    32,
+                ) => RelocationKind::Abs4,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_32_PCREL,
+                    },
+                    0,
+                ) => RelocationKind::PCRel4,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS_HI20,
+                    },
+                    0,
+                ) => RelocationKind::LArchAbsHi20,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS_LO12,
+                    },
+                    0,
+                ) => RelocationKind::LArchAbsLo12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS64_HI12,
+                    },
+                    0,
+                ) => RelocationKind::LArchAbs64Hi12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS64_LO20,
+                    },
+                    0,
+                ) => RelocationKind::LArchAbs64Lo20,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_CALL36,
+                    },
+                    0,
+                ) => RelocationKind::LArchCall36,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA_HI20,
+                    },
+                    0,
+                ) => RelocationKind::LArchPCAlaHi20,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA_LO12,
+                    },
+                    0,
+                ) => RelocationKind::LArchPCAlaLo12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA64_HI12,
+                    },
+                    0,
+                ) => RelocationKind::LArchPCAla64Hi12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA64_LO20,
+                    },
+                    0,
+                ) => RelocationKind::LArchPCAla64Lo20,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADR_PREL_LO21,
+                    },
+                    0,
+                ) => RelocationKind::Aarch64AdrPrelLo21,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_64,
+                    },
+                    64,
+                ) => RelocationKind::Abs8,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_32_PCREL,
+                    },
+                    32,
+                ) => RelocationKind::PCRel4,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADR_PREL_PG_HI21,
+                    },
+                    0,
+                ) => RelocationKind::Aarch64AdrPrelPgHi21,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_LDST128_ABS_LO12_NC,
+                    },
+                    0,
+                ) => RelocationKind::Aarch64Ldst128AbsLo12Nc,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADD_ABS_LO12_NC,
+                    },
+                    0,
+                ) => RelocationKind::Aarch64AddAbsLo12Nc,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_LDST64_ABS_LO12_NC,
+                    },
+                    0,
+                ) => RelocationKind::Aarch64Ldst64AbsLo12Nc,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_PREL64,
+                    },
+                    64,
+                ) => RelocationKind::PCRel8,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ABS64,
+                    },
+                    64,
+                ) => RelocationKind::Abs8,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::MachO { r_type: 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::RelocationFlags::MachO { r_type: 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 +800,49 @@ 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),
+            )
+        })
+        .collect::<Result<Vec<SectionIndex>, _>>()?;
+
+    let gcc_except_table_section_indices = gcc_except_table_section_indices
+        .iter()
+        .map(|index| {
+            section_to_custom_section.get(index).map_or_else(
+                || {
+                    Err(CompileError::Codegen(format!(
+                        ".gcc_except_table section with index={index:?} was never loaded",
+                    )))
+                },
+                |idx| Ok(*idx),
+            )
+        })
+        .collect::<Result<Vec<SectionIndex>, _>>()?;
+
+    let data_dw_ref_personality_section_indices = data_dw_ref_personality_section_indices
+        .iter()
+        .map(|index| {
+            section_to_custom_section.get(index).map_or_else(
+                || {
+                    Err(CompileError::Codegen(format!(
+                        ".data.DW.ref.wasmer_eh_personality section with index={index:?} was never loaded",
                     )))
                 },
                 |idx| Ok(*idx),
@@ -354,17 +853,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 +874,7 @@ where
         .collect::<PrimaryMap<SectionIndex, _>>();
 
     let function_body = FunctionBody {
-        body: elf
+        body: obj
             .section_by_index(root_section_index)
             .unwrap()
             .data()
@@ -401,7 +896,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 +908,8 @@ where
         },
         custom_sections,
         eh_frame_section_indices,
+        compact_unwind_section_indices,
+        gcc_except_table_section_indices,
+        data_dw_ref_personality_section_indices,
     })
 }
diff --git a/lib/compiler-llvm/src/trampoline/wasm.rs b/lib/compiler-llvm/src/trampoline/wasm.rs
index a3be2314c0..f6c59fc093 100644
--- a/lib/compiler-llvm/src/trampoline/wasm.rs
+++ b/lib/compiler-llvm/src/trampoline/wasm.rs
@@ -1,40 +1,74 @@
-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;
+// TODO: Remove
+#![allow(unused)]
+
+use crate::{
+    abi::{Abi, G0M0FunctionKind, get_abi},
+    config::LLVM,
+    error::{err, err_nt},
+    object_file::{CompiledFunction, load_object_file},
+    translator::intrinsics::{Intrinsics, type_to_llvm, type_to_llvm_ptr},
+};
 use inkwell::{
+    AddressSpace, DLLStorageClass,
     attributes::{Attribute, AttributeLoc},
     context::Context,
     module::{Linkage, Module},
-    passes::PassManager,
+    passes::PassBuilderOptions,
     targets::{FileType, TargetMachine},
-    types::{BasicType, FunctionType},
-    values::FunctionValue,
-    AddressSpace, DLLStorageClass,
+    types::FunctionType,
+    values::{BasicMetadataValueEnum, FunctionValue},
+};
+use std::{cmp, convert::TryInto};
+use target_lexicon::{BinaryFormat, Triple};
+use wasmer_compiler::{
+    misc::CompiledKind,
+    types::{
+        function::FunctionBody,
+        module::CompileModuleInfo,
+        relocation::{Relocation, RelocationTarget},
+        section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
+    },
 };
-use std::cmp;
-use std::convert::TryInto;
 use wasmer_types::{
-    CompileError, FunctionBody, FunctionType as FuncType, LocalFunctionIndex, RelocationTarget,
+    CompileError, FunctionIndex, FunctionType as FuncType, LocalFunctionIndex, entity::PrimaryMap,
 };
+use wasmer_vm::MemoryStyle;
 
 pub struct FuncTrampoline {
     ctx: Context,
     target_machine: TargetMachine,
+    target_triple: Triple,
     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,
+        target_triple: Triple,
+        binary_fmt: BinaryFormat,
+    ) -> Result<Self, CompileError> {
         let abi = get_abi(&target_machine);
-        Self {
+        Ok(Self {
             ctx: Context::create(),
             target_machine,
+            target_triple,
             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,25 +76,38 @@ impl FuncTrampoline {
         ty: &FuncType,
         config: &LLVM,
         name: &str,
-    ) -> Result<Module, CompileError> {
+        compile_info: &CompileModuleInfo,
+    ) -> Result<Module<'_>, CompileError> {
         // The function type, used for the callbacks.
         let function = CompiledKind::FunctionCallTrampoline(ty.clone());
         let module = self.ctx.create_module("");
         let target_machine = &self.target_machine;
         let target_triple = target_machine.get_triple();
-        let target_data = target_machine.get_target_data();
+        let target_data: inkwell::targets::TargetData = 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.target_triple,
+            &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 +115,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,
@@ -85,23 +136,27 @@ impl FuncTrampoline {
         )?;
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.preopt_ir(&function, &module);
+            callbacks.preopt_ir(&function, &compile_info.module.hash_string(), &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);
+            callbacks.postopt_ir(&function, &compile_info.module.hash_string(), &module);
         }
-
         Ok(module)
     }
 
@@ -110,8 +165,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;
 
@@ -120,32 +176,53 @@ impl FuncTrampoline {
             .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.obj_memory_buffer(&function, &memory_buffer);
+            let module_hash = compile_info.module.hash_string();
+            callbacks.obj_memory_buffer(&function, &module_hash, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, &module_hash, &asm_buffer);
         }
 
         let mem_buf_slice = memory_buffer.as_slice();
+
+        // Use a dummy function index to detect relocations against the trampoline
+        // function's address, which shouldn't exist and are not supported.
+        // Note, we just drop all custom sections, and verify that the function
+        // body itself has no relocations at all. This value should never be
+        // touched at all. However, it is set up so that if we do touch it (maybe
+        // due to someone changing the code later on), it'll explode, which is desirable!
+        let dummy_reloc_target =
+            RelocationTarget::DynamicTrampoline(FunctionIndex::from_u32(u32::MAX - 1));
+
+        // Note: we don't count .gcc_except_table here because native-to-wasm
+        // trampolines are not supposed to generate any LSDA sections. We *want* them
+        // to terminate libunwind's stack searches.
         let CompiledFunction {
             compiled_function,
             custom_sections,
             eh_frame_section_indices,
+            mut compact_unwind_section_indices,
+            ..
         } = load_object_file(
             mem_buf_slice,
-            FUNCTION_SECTION,
-            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            &self.func_section,
+            dummy_reloc_target,
             |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;
@@ -175,7 +252,8 @@ impl FuncTrampoline {
         ty: &FuncType,
         config: &LLVM,
         name: &str,
-    ) -> Result<Module, CompileError> {
+        module_hash: &Option<String>,
+    ) -> Result<Module<'_>, CompileError> {
         // The function type, used for the callbacks
         let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
         let module = self.ctx.create_module("");
@@ -184,18 +262,26 @@ 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.target_triple,
+            &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));
+        trampoline_func.set_personality_function(intrinsics.personality);
+        trampoline_func.add_attribute(AttributeLoc::Function, intrinsics.frame_pointer);
         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);
@@ -205,42 +291,60 @@ impl FuncTrampoline {
         self.generate_dynamic_trampoline(trampoline_func, ty, &self.ctx, &intrinsics)?;
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.preopt_ir(&function, &module);
+            callbacks.preopt_ir(&function, module_hash, &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);
+            callbacks.postopt_ir(&function, module_hash, &module);
         }
 
         Ok(module)
     }
+
+    #[allow(clippy::too_many_arguments)]
     pub fn dynamic_trampoline(
         &self,
         ty: &FuncType,
         config: &LLVM,
         name: &str,
+        dynamic_trampoline_index: u32,
+        final_module_custom_sections: &mut PrimaryMap<SectionIndex, CustomSection>,
+        eh_frame_section_bytes: &mut Vec<u8>,
+        eh_frame_section_relocations: &mut Vec<Relocation>,
+        compact_unwind_section_bytes: &mut Vec<u8>,
+        compact_unwind_section_relocations: &mut Vec<Relocation>,
+        module_hash: &Option<String>,
     ) -> Result<FunctionBody, CompileError> {
         let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
         let target_machine = &self.target_machine;
 
-        let module = self.dynamic_trampoline_to_module(ty, config, name)?;
+        let module = self.dynamic_trampoline_to_module(ty, config, name, module_hash)?;
 
         let memory_buffer = target_machine
             .write_to_memory_buffer(&module, FileType::Object)
             .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.obj_memory_buffer(&function, &memory_buffer);
+            callbacks.obj_memory_buffer(&function, module_hash, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, module_hash, &asm_buffer)
         }
 
         let mem_buf_slice = memory_buffer.as_slice();
@@ -248,35 +352,21 @@ impl FuncTrampoline {
             compiled_function,
             custom_sections,
             eh_frame_section_indices,
+            compact_unwind_section_indices,
+            gcc_except_table_section_indices,
+            data_dw_ref_personality_section_indices,
         } = load_object_file(
             mem_buf_slice,
-            FUNCTION_SECTION,
-            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            &self.func_section,
+            RelocationTarget::DynamicTrampoline(FunctionIndex::from_u32(dynamic_trampoline_index)),
             |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() {
-            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() {
-                if idx as u32 != section_idx.as_u32() {
-                    all_sections_are_eh_sections = false;
-                    break;
-                }
-            }
-        }
-        if !all_sections_are_eh_sections {
-            return Err(CompileError::Codegen(
-                "trampoline generation produced non-eh custom sections".into(),
-            ));
-        }
+
         if !compiled_function.relocations.is_empty() {
             return Err(CompileError::Codegen(
                 "trampoline generation produced relocations".into(),
@@ -284,14 +374,78 @@ impl FuncTrampoline {
         }
         // Ignore CompiledFunctionFrameInfo. Extra frame info isn't a problem.
 
+        // Also append EH-related sections to the final module, since we expect
+        // dynamic trampolines to participate in unwinding
+        {
+            let first_section = final_module_custom_sections.len() as u32;
+            for (section_index, mut custom_section) in custom_sections.into_iter() {
+                for reloc in &mut custom_section.relocations {
+                    if let RelocationTarget::CustomSection(index) = reloc.reloc_target {
+                        reloc.reloc_target = RelocationTarget::CustomSection(
+                            SectionIndex::from_u32(first_section + index.as_u32()),
+                        )
+                    }
+
+                    if reloc.kind.needs_got() {
+                        return Err(CompileError::Codegen(
+                            "trampoline generation produced GOT relocation".into(),
+                        ));
+                    }
+                }
+
+                if eh_frame_section_indices.contains(&section_index) {
+                    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());
+                    // Terminate the eh_frame info with a zero-length CIE.
+                    eh_frame_section_bytes.extend_from_slice(&[0, 0, 0, 0]);
+                    eh_frame_section_relocations.extend(custom_section.relocations);
+                    // TODO: we do this to keep the count right, remove it.
+                    final_module_custom_sections.push(CustomSection {
+                        protection: CustomSectionProtection::Read,
+                        alignment: None,
+                        bytes: SectionBody::new_with_vec(vec![]),
+                        relocations: vec![],
+                    });
+                } else if 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;
+                    }
+                    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.
+                    final_module_custom_sections.push(CustomSection {
+                        protection: CustomSectionProtection::Read,
+                        alignment: None,
+                        bytes: SectionBody::new_with_vec(vec![]),
+                        relocations: vec![],
+                    });
+                } else if gcc_except_table_section_indices.contains(&section_index)
+                    || data_dw_ref_personality_section_indices.contains(&section_index)
+                {
+                    final_module_custom_sections.push(custom_section);
+                } else {
+                    return Err(CompileError::Codegen(
+                        "trampoline generation produced non-eh custom sections".into(),
+                    ));
+                }
+            }
+        }
+
         Ok(FunctionBody {
             body: compiled_function.body.body,
             unwind_info: compiled_function.body.unwind_info,
         })
     }
 
+    #[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,
@@ -313,12 +467,16 @@ impl FuncTrampoline {
                 _ => {
                     return Err(CompileError::Codegen(
                         "trampoline function unimplemented".to_string(),
-                    ))
+                    ));
                 }
             };
 
         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 +486,169 @@ 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();
+
+                err!(builder.build_load(intrinsics.ptr_ty, global_ptr_ptr, "")).into_pointer_value()
+            };
+
+            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();
+
+                err!(builder.build_load(intrinsics.ptr_ty, memory_definition_ptr_ptr, ""))
+                    .into_pointer_value()
+            };
+            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 {
+                err!(builder.build_load(intrinsics.ptr_ty, base_ptr, "")).into_pointer_value()
+            };
+
+            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 +664,65 @@ 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,
-                trampoline_func
-                    .get_nth_param(i as u32 + first_user_param)
-                    .unwrap(),
+                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 +730,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 +760,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..ce663fe789 100644
--- a/lib/compiler-llvm/src/translator/code.rs
+++ b/lib/compiler-llvm/src/translator/code.rs
@@ -1,61 +1,112 @@
+use std::collections::HashMap;
+
 use super::{
     intrinsics::{
-        tbaa_label, type_to_llvm, CtxType, FunctionCache, GlobalCache, Intrinsics, MemoryCache,
+        CtxType, FunctionCache, GlobalCache, Intrinsics, MemoryCache, tbaa_label, type_to_llvm,
     },
     // stackmap::{StackmapEntry, StackmapEntryKind, StackmapRegistry, ValueSemantic},
-    state::{ControlFrame, ExtraInfo, IfElseState, State},
+    state::{ControlFrame, ExtraInfo, IfElseState, State, TagCatchInfo},
 };
 use inkwell::{
-    attributes::AttributeLoc,
+    AddressSpace, AtomicOrdering, AtomicRMWBinOp, DLLStorageClass, FloatPredicate, IntPredicate,
+    attributes::{Attribute, 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,
+        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::{Architecture, BinaryFormat, OperatingSystem, Triple};
 
-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::{Abi, G0M0FunctionKind, LocalFunctionG0M0params, get_abi},
+    config::LLVM,
+    error::{err, err_nt},
+    object_file::{CompiledFunction, load_object_file},
+};
 use wasmer_compiler::{
-    from_binaryreadererror_wasmerror, wpheaptype_to_type, wptype_to_type, FunctionBinaryReader,
-    FunctionBodyData, MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
+    CANONICAL_NAN_F32, CANONICAL_NAN_F64, FunctionBinaryReader, FunctionBodyData,
+    GEF32_LEQ_I32_MAX, GEF32_LEQ_I64_MAX, GEF32_LEQ_U32_MAX, GEF32_LEQ_U64_MAX, GEF64_LEQ_I32_MAX,
+    GEF64_LEQ_I64_MAX, GEF64_LEQ_U32_MAX, GEF64_LEQ_U64_MAX, LEF32_GEQ_I32_MIN, LEF32_GEQ_I64_MIN,
+    LEF32_GEQ_U32_MIN, LEF32_GEQ_U64_MIN, LEF64_GEQ_I32_MIN, LEF64_GEQ_I64_MIN, LEF64_GEQ_U32_MIN,
+    LEF64_GEQ_U64_MIN, MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
+    from_binaryreadererror_wasmerror,
+    misc::CompiledKind,
+    types::{
+        relocation::RelocationTarget,
+        symbols::{Symbol, SymbolRegistry},
+    },
+    wasmparser::{Catch, MemArg, Operator},
+    wpheaptype_to_type, wptype_to_type,
 };
-use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex,
-    ModuleInfo, RelocationTarget, SignatureIndex, Symbol, SymbolRegistry, TableIndex, Type,
+    ModuleInfo, SignatureIndex, TableIndex, Type,
 };
+use wasmer_types::{TagIndex, entity::PrimaryMap};
 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;
+
+// Use the lowest optimization level for very large function bodies to reduce compile time.
+// See #5997 for more numbers connected to the change.
+const LLVMIR_LARGE_FUNCTION_THRESHOLD: usize = 100_000;
 
 pub struct FuncTranslator {
     ctx: Context,
+    target_triple: Triple,
     target_machine: TargetMachine,
+    target_machine_no_opt: Option<TargetMachine>,
     abi: Box<dyn Abi>,
+    binary_fmt: BinaryFormat,
+    func_section: String,
+    pointer_width: u8,
 }
 
 impl FuncTranslator {
-    pub fn new(target_machine: TargetMachine) -> Self {
+    pub fn new(
+        target_triple: Triple,
+        target_machine: TargetMachine,
+        target_machine_no_opt: Option<TargetMachine>,
+        binary_fmt: BinaryFormat,
+        pointer_width: u8,
+    ) -> Result<Self, CompileError> {
         let abi = get_abi(&target_machine);
-        Self {
+        Ok(Self {
             ctx: Context::create(),
+            target_triple,
             target_machine,
+            target_machine_no_opt,
             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,
+            pointer_width,
+        })
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -69,15 +120,25 @@ impl FuncTranslator {
         memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
         _table_styles: &PrimaryMap<TableIndex, TableStyle>,
         symbol_registry: &dyn SymbolRegistry,
-    ) -> Result<Module, CompileError> {
+        target: &Triple,
+    ) -> Result<Module<'_>, CompileError> {
         // The function type, used for the callbacks.
-        let function = CompiledKind::Local(*local_func_index);
         let func_index = wasm_module.func_index(*local_func_index);
+        let function =
+            CompiledKind::Local(*local_func_index, wasm_module.get_function_name(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());
 
@@ -91,21 +152,50 @@ impl FuncTranslator {
             .get(wasm_module.functions[func_index])
             .unwrap();
 
-        // 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 offsets = VMOffsets::new(self.pointer_width, wasm_module);
+        let intrinsics = Intrinsics::declare(
+            &module,
+            &self.ctx,
+            &target_data,
+            &self.target_triple,
+            &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 {
             func.add_attribute(*attr_loc, *attr);
         }
 
-        func.add_attribute(AttributeLoc::Function, intrinsics.stack_probe);
+        if !matches!(target.operating_system, OperatingSystem::Windows) {
+            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 +207,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 +217,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 +237,59 @@ 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 +297,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 +319,14 @@ 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,
+                self.pointer_width,
+            ),
             unreachable_depth: 0,
             memory_styles,
             _table_styles,
@@ -204,7 +336,11 @@ impl FuncTranslator {
             symbol_registry,
             abi: &*self.abi,
             config,
+            target_triple: self.target_triple.clone(),
+            tags_cache: HashMap::new(),
+            binary_fmt: self.binary_fmt,
         };
+
         fcg.ctx.add_func(
             func_index,
             func.as_global_value().as_pointer_value(),
@@ -222,48 +358,52 @@ impl FuncTranslator {
         fcg.finalize(wasm_fn_type)?;
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.preopt_ir(&function, &module);
+            callbacks.preopt_ir(&function, &wasm_module.hash_string(), &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");
+
+        module
+            .run_passes(
+                passes.join(",").as_str(),
+                target_machine,
+                PassBuilderOptions::create(),
+            )
+            .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.postopt_ir(&function, &module);
+            callbacks.postopt_ir(&function, &wasm_module.hash_string(), &module);
         }
 
         Ok(module)
@@ -280,6 +420,7 @@ impl FuncTranslator {
         memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
         table_styles: &PrimaryMap<TableIndex, TableStyle>,
         symbol_registry: &dyn SymbolRegistry,
+        target: &Triple,
     ) -> Result<CompiledFunction, CompileError> {
         let module = self.translate_to_module(
             wasm_module,
@@ -290,59 +431,88 @@ impl FuncTranslator {
             memory_styles,
             table_styles,
             symbol_registry,
+            target,
         )?;
-        let function = CompiledKind::Local(*local_func_index);
-        let target_machine = &self.target_machine;
+        let function = CompiledKind::Local(
+            *local_func_index,
+            wasm_module.get_function_name(wasm_module.func_index(*local_func_index)),
+        );
+
+        let target_machine = if function_body.data.len() > LLVMIR_LARGE_FUNCTION_THRESHOLD {
+            self.target_machine_no_opt
+                .as_ref()
+                .unwrap_or(&self.target_machine)
+        } else {
+            &self.target_machine
+        };
         let memory_buffer = target_machine
             .write_to_memory_buffer(&module, FileType::Object)
             .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
-            callbacks.obj_memory_buffer(&function, &memory_buffer);
+            let module_hash = wasm_module.hash().map(|m| m.to_string());
+            callbacks.obj_memory_buffer(&function, &module_hash, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, &module_hash, &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(),
-                value,
-                self.intrinsics.i32_zero,
+                self.intrinsics
+                    .i32_ty
+                    .vec_type(vec_ty.get_size())
+                    .const_zero(),
                 "",
-            ),
-            vec_ty.get_undef(),
-            self.intrinsics
-                .i32_ty
-                .vec_type(vec_ty.get_size())
-                .const_zero(),
-            "",
+            )
         )
     }
 
@@ -358,7 +528,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 +553,71 @@ 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 +626,19 @@ 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
-            .build_select(below_lower_bound_cmp, int_min_value, value, "")
-            .into_vector_value()
+        err_nt!(
+            self.builder
+                .build_select(below_lower_bound_cmp, int_min_value, value, "")
+                .map(|v| v.into_vector_value())
+        )
     }
 
     // Convert floating point vector to integer and saturate when out of range.
@@ -476,7 +653,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 +662,12 @@ 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 +680,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,84 +701,99 @@ 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(
         &self,
         lower_bound: u64, // Inclusive (not a trapping value)
         upper_bound: u64, // Inclusive (not a trapping value)
-        value: FloatValue,
-    ) {
+        value: FloatValue<'ctx>,
+    ) -> Result<(), CompileError> {
         let float_ty = value.get_type();
         let int_ty = if float_ty == self.intrinsics.f32_ty {
             self.intrinsics.i32_ty
@@ -607,35 +801,39 @@ 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, "")
-            .into_float_value();
-        let upper_bound = self
-            .builder
-            .build_bitcast(int_ty.const_int(upper_bound, false), float_ty, "")
-            .into_float_value();
+        let lower_bound = err!(self.builder.build_bit_cast(
+            int_ty.const_int(lower_bound, false),
+            float_ty,
+            ""
+        ))
+        .into_float_value();
+        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,74 +842,89 @@ 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);
+        err!(
+            self.builder
+                .build_conditional_branch(out_of_bounds, failure_block, continue_block)
+        );
         self.builder.position_at_end(failure_block);
-        let is_nan = self
-            .builder
-            .build_float_compare(FloatPredicate::UNO, value, value, "is_nan");
-        let trap_code = self.builder.build_select(
+        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();
+        ));
+        self.build_call_with_param_attributes(
+            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<'ctx>,
+        right: IntValue<'ctx>,
+    ) -> 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(
+            .build_call_with_param_attributes(
                 self.intrinsics.expect_i1,
                 &[
                     should_trap.into(),
                     self.intrinsics.i1_ty.const_zero().into(),
                 ],
                 "should_trap_expect",
-            )
+            )?
             .try_as_basic_value()
-            .left()
-            .unwrap()
+            .unwrap_basic()
             .into_int_value();
 
         let shouldnt_trap_block = self
@@ -720,43 +933,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,
             "",
+        ));
+        err!(
+            self.builder
+                .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw")
         );
-        self.builder
-            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
-        self.builder.build_unreachable();
+        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<'ctx>) -> 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(
+            .build_call_with_param_attributes(
                 self.intrinsics.expect_i1,
                 &[
                     should_trap.into(),
                     self.intrinsics.i1_ty.const_zero().into(),
                 ],
                 "should_trap_expect",
-            )
+            )?
             .try_as_basic_value()
-            .left()
-            .unwrap()
+            .unwrap_basic()
             .into_int_value();
 
         let shouldnt_trap_block = self
@@ -765,16 +983,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(
+        self.build_call_with_param_attributes(
             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 +1005,37 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
         int_vec_ty: VectorType<'ctx>,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
-        let (value, info) = if info.has_pending_f32_nan() {
-            let value = self
-                .builder
-                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
-        } else if info.has_pending_f64_nan() {
-            let value = self
-                .builder
-                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
+        let (value, info) = if self.config.enable_nan_canonicalization {
+            if info.has_pending_f32_nan() {
+                let value = err!(
+                    self.builder
+                        .build_bit_cast(value, self.intrinsics.f32x4_ty, "")
+                );
+                (self.canonicalize_nans(value)?, info.strip_pending())
+            } else if info.has_pending_f64_nan() {
+                let value = err!(
+                    self.builder
+                        .build_bit_cast(value, self.intrinsics.f64x2_ty, "")
+                );
+                (self.canonicalize_nans(value)?, info.strip_pending())
+            } else {
+                (value, info)
+            }
         } 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 +1043,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 +1051,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 +1059,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 +1069,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
-        let (value, info) = if info.has_pending_f64_nan() {
-            let value = self
-                .builder
-                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
+        let (value, info) = if self.config.enable_nan_canonicalization && info.has_pending_f64_nan()
+        {
+            let value = err!(
+                self.builder
+                    .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 +1096,34 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
-        let (value, info) = if info.has_pending_f32_nan() {
-            let value = self
-                .builder
-                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
+        let (value, info) = if self.config.enable_nan_canonicalization && info.has_pending_f32_nan()
+        {
+            let value = err!(
+                self.builder
+                    .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 +1131,12 @@ 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
-                    .builder
-                    .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-                let value = self.canonicalize_nans(value);
-                self.builder.build_bitcast(value, ty, "")
+                let value = err!(
+                    self.builder
+                        .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 +1145,27 @@ 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
-                    .builder
-                    .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-                let value = self.canonicalize_nans(value);
-                self.builder.build_bitcast(value, ty, "")
+                let value = err!(
+                    self.builder
+                        .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,73 +1173,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
-                .build_select(nan_cmp, canonical_qnan, value, "")
-                .as_basic_value_enum()
+                .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, "")
+                    .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
-                .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()
-        }
-    }
-
-    fn quiet_nan(&self, value: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {
-        let intrinsic = if value
-            .get_type()
-            .eq(&self.intrinsics.f32_ty.as_basic_type_enum())
-        {
-            Some(self.intrinsics.add_f32)
-        } else if value
-            .get_type()
-            .eq(&self.intrinsics.f64_ty.as_basic_type_enum())
-        {
-            Some(self.intrinsics.add_f64)
-        } else if value
-            .get_type()
-            .eq(&self.intrinsics.f32x4_ty.as_basic_type_enum())
-        {
-            Some(self.intrinsics.add_f32x4)
-        } else if value
-            .get_type()
-            .eq(&self.intrinsics.f64x2_ty.as_basic_type_enum())
-        {
-            Some(self.intrinsics.add_f64x2)
-        } else {
-            None
-        };
-
-        match intrinsic {
-            Some(intrinsic) => self
-                .builder
-                .build_call(
-                    intrinsic,
-                    &[
-                        value.into(),
-                        value.get_type().const_zero().into(),
-                        self.intrinsics.fp_rounding_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                )
-                .try_as_basic_value()
-                .left()
-                .unwrap(),
-            None => value,
+            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_select(nan_cmp, canonical_qnan, value, "")
+                    .map(|v| v.as_basic_value_enum())
+            )
         }
     }
 
@@ -1016,7 +1219,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 +1265,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,
@@ -1081,41 +1286,55 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     let ptr_in_bounds = if offset.is_const() {
                         // When the offset is constant, if it's below the minimum
                         // memory size, we've statically shown that it's safe.
-                        let load_offset_end = offset.const_add(value_size_v);
-                        let ptr_in_bounds = load_offset_end.const_int_compare(
-                            IntPredicate::ULE,
-                            intrinsics.i64_ty.const_int(minimum.bytes().0 as u64, false),
-                        );
-                        if ptr_in_bounds.get_zero_extended_constant() == Some(1) {
-                            Some(ptr_in_bounds)
+                        let load_offset_end =
+                            offset.const_add(value_size_v).get_zero_extended_constant();
+                        if load_offset_end.is_some_and(|load_offset_end| {
+                            load_offset_end <= minimum.bytes().0 as u64
+                        }) {
+                            Some(intrinsics.i64_ty.const_int(1, false))
                         } else {
                             None
                         }
                     } 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, "");
-
-                        builder.build_int_compare(
-                            IntPredicate::ULE,
-                            load_offset_end,
-                            current_length,
-                            "",
-                        )
-                    });
+                            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",
+                            ))
+                        }
+                    };
+
                     if !ptr_in_bounds.is_constant_int()
                         || ptr_in_bounds.get_zero_extended_constant().unwrap() != 1
                     {
@@ -1124,41 +1343,39 @@ 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!(self.build_call_with_param_attributes(
+                            intrinsics.expect_i1,
+                            &[
+                                ptr_in_bounds.into(),
+                                intrinsics.i1_ty.const_int(1, true).into(),
+                            ],
+                            "ptr_in_bounds_expect",
+                        ))
+                        .try_as_basic_value()
+                        .unwrap_basic()
+                        .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!(self.build_call_with_param_attributes(
                             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,42 +1385,54 @@ 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 = err!(self.builder.build_int_compare(
+            IntPredicate::EQ,
+            and,
+            self.intrinsics.i64_zero,
+            "is_aligned"
+        ));
         let aligned = self
-            .builder
-            .build_call(
+            .build_call_with_param_attributes(
                 self.intrinsics.expect_i1,
                 &[
                     aligned.into(),
                     self.intrinsics.i1_ty.const_int(1, false).into(),
                 ],
-                "",
-            )
+                "is_aligned_expect",
+            )?
             .try_as_basic_value()
-            .left()
-            .unwrap()
+            .unwrap_basic()
             .into_int_value();
 
         let continue_block = self
@@ -1212,29 +1441,36 @@ 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(
+        self.build_call_with_param_attributes(
             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
-            .into_iter()
-            .map(|(v, i)| self.apply_pending_canonicalization(v, i));
+        let results = err!(
+            results
+                .into_iter()
+                .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,31 +1486,334 @@ 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 {
+            err!(
+                self.builder
+                    .build_return(Some(&self.abi.pack_values_for_register_return(
+                        self.intrinsics,
+                        &self.builder,
+                        &results,
+                        &func_type,
+                    )?))
+            );
+        }
+        Ok(())
+    }
+
+    // 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 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(),
+        );
+
+        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 tag_glbl = tag_glbl.as_basic_value_enum();
+
+        self.tags_cache.insert(tag, tag_glbl);
+        tag_glbl
+    }
+
+    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(),
+            ));
+        };
+
+        let mut local_func_indices = vec![];
+        let mut foreign_func_indices = vec![];
+
+        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;
+            }
+        }
+
+        // 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
-                .build_return(Some(&self.abi.pack_values_for_register_return(
-                    self.intrinsics,
-                    &self.builder,
-                    &results.collect::<Vec<_>>(),
-                    &func_type,
-                )?));
+                .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)
+    }
 }
 
 /*
@@ -1363,6 +1902,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 +1928,252 @@ pub struct LLVMFunctionCodeGenerator<'ctx, 'a> {
     symbol_registry: &'a dyn SymbolRegistry,
     abi: &'a dyn Abi,
     config: &'a LLVM,
+    target_triple: Triple,
+    tags_cache: HashMap<i32, BasicValueEnum<'ctx>>,
+    binary_fmt: target_lexicon::BinaryFormat,
 }
 
-impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
+impl<'ctx> LLVMFunctionCodeGenerator<'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())
+        {
+            Some(self.intrinsics.add_f32)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f64_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f64)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f32x4_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f32x4)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f64x2_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f64x2)
+        } else {
+            None
+        };
+
+        match intrinsic {
+            Some(intrinsic) => err_nt!(
+                self.builder
+                    .build_call(
+                        intrinsic,
+                        &[
+                            value.into(),
+                            value.get_type().const_zero().into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .map(|v| v.try_as_basic_value().unwrap_basic())
+            ),
+            None => Ok(value),
+        }
+    }
+
+    fn finalize_minmax_result(
+        &self,
+        value: BasicValueEnum<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
+        let ty = value.get_type();
+        if ty.eq(&self.intrinsics.f32_ty.as_basic_type_enum())
+            || ty.eq(&self.intrinsics.f64_ty.as_basic_type_enum())
+        {
+            let value = value.into_float_value();
+            let is_nan = err!(self.builder.build_float_compare(
+                FloatPredicate::UNO,
+                value,
+                value,
+                "res_is_nan"
+            ));
+            let quiet = self.quiet_nan(value.as_basic_value_enum())?;
+            let result =
+                err!(
+                    self.builder
+                        .build_select(is_nan, quiet, value.as_basic_value_enum(), "")
+                );
+            Ok(result.as_basic_value_enum())
+        } else if ty.eq(&self.intrinsics.f32x4_ty.as_basic_type_enum()) {
+            let value = value.into_vector_value();
+            let is_nan = self
+                .build_call_with_param_attributes(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        value.into(),
+                        value.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                )?
+                .try_as_basic_value()
+                .unwrap_basic()
+                .into_vector_value();
+            let quiet = self
+                .quiet_nan(value.as_basic_value_enum())?
+                .into_vector_value();
+            let result = err!(self.builder.build_select(
+                is_nan,
+                quiet.as_basic_value_enum(),
+                value.as_basic_value_enum(),
+                "",
+            ));
+            Ok(result.as_basic_value_enum())
+        } else if ty.eq(&self.intrinsics.f64x2_ty.as_basic_type_enum()) {
+            let value = value.into_vector_value();
+            let is_nan = self
+                .build_call_with_param_attributes(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        value.into(),
+                        value.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                )?
+                .try_as_basic_value()
+                .unwrap_basic()
+                .into_vector_value();
+            let quiet = self
+                .quiet_nan(value.as_basic_value_enum())?
+                .into_vector_value();
+            let result = err!(self.builder.build_select(
+                is_nan,
+                quiet.as_basic_value_enum(),
+                value.as_basic_value_enum(),
+                "",
+            ));
+            Ok(result.as_basic_value_enum())
+        } else {
+            Ok(value)
+        }
+    }
+
+    fn finalize_rounding_result(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> Result<(BasicValueEnum<'ctx>, ExtraInfo), CompileError> {
+        let ty = value.get_type();
+        let is_f32 = ty.eq(&self.intrinsics.f32_ty.as_basic_type_enum());
+        let is_f64 = ty.eq(&self.intrinsics.f64_ty.as_basic_type_enum());
+        let is_f32x4 = ty.eq(&self.intrinsics.f32x4_ty.as_basic_type_enum());
+        let is_f64x2 = ty.eq(&self.intrinsics.f64x2_ty.as_basic_type_enum());
+        debug_assert!(is_f32 || is_f64 || is_f32x4 || is_f64x2);
+
+        if matches!(
+            self.target_triple.architecture,
+            Architecture::Riscv32(..) | Architecture::Riscv64(..)
+        ) {
+            if is_f32 || is_f64 {
+                let input = value.into_float_value();
+                let is_nan = err!(self.builder.build_float_compare(
+                    FloatPredicate::UNO,
+                    input,
+                    input,
+                    "res_is_nan",
+                ));
+                let canonical_nan_bits = if is_f32 {
+                    self.intrinsics
+                        .i32_ty
+                        .const_int(CANONICAL_NAN_F32 as _, false)
+                } else {
+                    self.intrinsics.i64_ty.const_int(CANONICAL_NAN_F64, false)
+                };
+                let canonical_nan = err!(self.builder.build_bit_cast(
+                    canonical_nan_bits,
+                    ty,
+                    "canonical_nan",
+                ));
+                let res =
+                    err!(
+                        self.builder
+                            .build_select(is_nan, canonical_nan, value, "canonical_nan",)
+                    );
+                Ok((res, info))
+            } else if is_f32x4 {
+                let value = value.into_vector_value();
+                let is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        value.into(),
+                        value.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .unwrap_basic()
+                .into_vector_value();
+                let canonical_nan_bits = self
+                    .intrinsics
+                    .i32_ty
+                    .const_int(CANONICAL_NAN_F32 as _, false);
+                let canonical_nan_bits = VectorType::const_vector(&[canonical_nan_bits; 4]);
+                let canonical_nan = err!(self.builder.build_bit_cast(
+                    canonical_nan_bits,
+                    self.intrinsics.f32x4_ty,
+                    "canonical_nan",
+                ));
+                let res = err!(self.builder.build_select(
+                    is_nan,
+                    canonical_nan.as_basic_value_enum(),
+                    value.as_basic_value_enum(),
+                    "canonical_nan",
+                ));
+                Ok((res, info))
+            } else {
+                let value = value.into_vector_value();
+                let is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        value.into(),
+                        value.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .unwrap_basic()
+                .into_vector_value();
+                let canonical_nan_bits = self.intrinsics.i64_ty.const_int(CANONICAL_NAN_F64, false);
+                let canonical_nan_bits = VectorType::const_vector(&[canonical_nan_bits; 2]);
+                let canonical_nan = err!(self.builder.build_bit_cast(
+                    canonical_nan_bits,
+                    self.intrinsics.f64x2_ty,
+                    "canonical_nan",
+                ));
+                let res = err!(self.builder.build_select(
+                    is_nan,
+                    canonical_nan.as_basic_value_enum(),
+                    value.as_basic_value_enum(),
+                    "canonical_nan",
+                ));
+                Ok((res, info))
+            }
+        } else {
+            Ok((
+                value,
+                (info
+                    | if is_f32 || is_f32x4 {
+                        ExtraInfo::pending_f32_nan()
+                    } else {
+                        ExtraInfo::pending_f64_nan()
+                    })?,
+            ))
+        }
+    }
+
     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.
@@ -1402,7 +2185,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             match op {
                 Operator::Block { blockty: _ }
                 | Operator::Loop { blockty: _ }
-                | Operator::If { blockty: _ } => {
+                | Operator::If { blockty: _ }
+                | Operator::TryTable { .. } => {
                     self.unreachable_depth += 1;
                     return Ok(());
                 }
@@ -1443,16 +2227,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 +2249,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 +2257,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 +2268,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 +2305,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 +2338,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 +2347,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 +2407,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 +2435,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 +2448,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 +2467,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 +2497,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     then_phis,
                     else_phis,
                     end_phis,
+                    block_param_types.len(),
                 );
             }
             Operator::Else => {
@@ -1748,12 +2509,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 +2551,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 +2570,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 +2585,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 +2607,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(
+                self.build_call_with_param_attributes(
                     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 +2664,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     Default::default()
                 };
-                let f = self
-                    .builder
-                    .build_bitcast(bits, self.intrinsics.f32_ty, "f");
+                let f = err!(
+                    self.builder
+                        .build_bit_cast(bits, self.intrinsics.f32_ty, "f")
+                );
                 self.state.push1_extra(f, info);
             }
             Operator::F64Const { value } => {
@@ -1941,9 +2677,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     Default::default()
                 };
-                let f = self
-                    .builder
-                    .build_bitcast(bits, self.intrinsics.f64_ty, "f");
+                let f = err!(
+                    self.builder
+                        .build_bit_cast(bits, self.intrinsics.f64_ty, "f")
+                );
                 self.state.push1_extra(f, info);
             }
             Operator::V128Const { value } => {
@@ -1981,47 +2718,67 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::I8x16Splat => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = v.into_int_value();
-                let v = 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, "");
+                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_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
-                    .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, "");
+                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_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 +2787,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 +2803,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 +2914,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 +2948,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 +2997,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 +3019,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 +3041,35 @@ 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,54 +3090,52 @@ 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(
+                    .build_call_with_param_attributes(
                         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()
+                    .unwrap_basic()
                     .into_int_value();
 
                 let in_bounds_continue_block = self
@@ -2333,52 +3144,51 @@ 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(
+                self.build_call_with_param_attributes(
                     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
-                        .builder
-                        .build_is_not_null(anyfunc_struct_ptr, "null funcref check");
+                    let funcref_not_null = err!(
+                        self.builder
+                            .build_is_not_null(anyfunc_struct_ptr, "null funcref check")
+                    );
 
                     let funcref_continue_deref_block = self
                         .context
@@ -2387,18 +3197,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(
+                    self.build_call_with_param_attributes(
                         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,48 +3241,54 @@ 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, "");
+                let initialized_and_sigindices_match = 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(
+                    .build_call_with_param_attributes(
                         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()
+                    .unwrap_basic()
                     .into_int_value();
 
                 let continue_block = self
@@ -2481,121 +3297,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();
-                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,
+                ));
+                self.build_call_with_param_attributes(
+                    self.intrinsics.throw_trap,
+                    &[trap_code.into()],
+                    "throw",
                 )?;
+                err!(self.builder.build_unreachable());
+                self.builder.position_at_end(continue_block);
 
-                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);
+                        .for_each(|ret| self.state.push1(*ret));
                 }
-                /*
-                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,
-                        )
-                    }
-                }
-                */
-
-                self.abi
-                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)
-                    .iter()
-                    .for_each(|ret| self.state.push1(*ret));
             }
 
             /***************************
@@ -2604,26 +3348,32 @@ 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 +3387,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 +3403,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 +3419,25 @@ 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 +3451,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 +3463,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 +3475,315 @@ 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 (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.sadd_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.sadd_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.uadd_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.uadd_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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, "");
-                self.state.push1(res);
+                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 (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.ssub_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.ssub_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.usub_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.usub_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .build_call_with_param_attributes(
+                        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, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(v1, self.intrinsics.i32x8_ty, "");
-                let v2 = self
-                    .builder
-                    .build_int_s_extend(v2, self.intrinsics.i32x8_ty, "");
-                let res = self.builder.build_int_mul(v1, v2, "");
+                let v1 = err!(
+                    self.builder
+                        .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 = 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 =
+                    let max_values = err!(self.builder.build_int_s_extend(
+                        max_values,
+                        self.intrinsics.i32x8_ty,
+                        ""
+                    ));
+                    err!(
                         self.builder
-                            .build_int_s_extend(max_values, self.intrinsics.i32x8_ty, "");
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, res, max_values, "")
+                            .build_int_compare(IntPredicate::SGT, res, max_values, "")
+                    )
                 };
 
-                let res = 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_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,55 +3792,62 @@ 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"),
                 };
                 let shuffle_array = match op {
                     Operator::I16x8ExtMulLowI8x16S | Operator::I16x8ExtMulLowI8x16U => [
                         self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
                         self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
                         self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
                         self.intrinsics.i32_consts[6],
-                        self.intrinsics.i32_consts[8],
-                        self.intrinsics.i32_consts[10],
-                        self.intrinsics.i32_consts[12],
-                        self.intrinsics.i32_consts[14],
+                        self.intrinsics.i32_consts[7],
                     ],
                     Operator::I16x8ExtMulHighI8x16S | Operator::I16x8ExtMulHighI8x16U => [
-                        self.intrinsics.i32_consts[1],
-                        self.intrinsics.i32_consts[3],
-                        self.intrinsics.i32_consts[5],
-                        self.intrinsics.i32_consts[7],
+                        self.intrinsics.i32_consts[8],
                         self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[10],
                         self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[12],
                         self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[14],
                         self.intrinsics.i32_consts[15],
                     ],
                     _ => 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 = 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, "")
                 );
-                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, "");
                 self.state.push1(res);
             }
             Operator::I32x4ExtMulLowI16x8S
@@ -3031,37 +3866,40 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let shuffle_array = match op {
                     Operator::I32x4ExtMulLowI16x8S | Operator::I32x4ExtMulLowI16x8U => [
                         self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
                         self.intrinsics.i32_consts[2],
-                        self.intrinsics.i32_consts[4],
-                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[3],
                     ],
                     Operator::I32x4ExtMulHighI16x8S | Operator::I32x4ExtMulHighI16x8U => [
-                        self.intrinsics.i32_consts[1],
-                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
                         self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
                         self.intrinsics.i32_consts[7],
                     ],
                     _ => 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 = 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, "")
                 );
-                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, "");
                 self.state.push1(res);
             }
             Operator::I64x2ExtMulLowI32x4S
@@ -3079,38 +3917,41 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 };
                 let shuffle_array = match op {
                     Operator::I64x2ExtMulLowI32x4S | Operator::I64x2ExtMulLowI32x4U => {
-                        [self.intrinsics.i32_consts[0], self.intrinsics.i32_consts[2]]
+                        [self.intrinsics.i32_consts[0], self.intrinsics.i32_consts[1]]
                     }
                     Operator::I64x2ExtMulHighI32x4S | Operator::I64x2ExtMulHighI32x4U => {
-                        [self.intrinsics.i32_consts[1], self.intrinsics.i32_consts[3]]
+                        [self.intrinsics.i32_consts[2], self.intrinsics.i32_consts[3]]
                     }
                     _ => 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 = 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, "")
                 );
-                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, "");
                 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 +3964,101 @@ 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(
+                ));
+                let v1_high = 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, "");
+                ));
+                let 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,772 +4071,906 @@ 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
-                    .builder
-                    .build_bitcast(v1, self.intrinsics.i1x128_ty, "")
-                    .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_bitcast(v2, self.intrinsics.i1x128_ty, "")
-                    .into_vector_value();
-                let cond = 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, "");
+                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_bit_cast(v1, self.intrinsics.i1x128_ty, "")
+                )
+                .into_vector_value();
+                let v2 = err!(
+                    self.builder
+                        .build_bit_cast(v2, self.intrinsics.i1x128_ty, "")
+                )
+                .into_vector_value();
+                let cond = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i16_ty, "")
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i8_ty, "")
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i4_ty, "")
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i2_ty, "")
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .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 = 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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_consts[15], "")
+                );
+                let v2 = 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 = 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::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 =
+                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_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, "");
+                        .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 =
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(
                     self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = 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_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_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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .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 = 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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_consts[15], "")
+                );
+                let v2 = 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 = 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::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 =
+                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_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, "");
+                        .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 =
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(
                     self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = 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_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_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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .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 = 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
-                    .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = 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, "");
+                let v2 = err!(
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_consts[15], "")
+                );
+                let v2 = 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 = 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::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 =
+                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_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, "");
+                        .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 =
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(
                     self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = 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_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_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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.ctlz_i32,
                         &[input.into(), is_zero_undef.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.ctlz_i64,
                         &[input.into(), is_zero_undef.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.cttz_i32,
                         &[input.into(), is_zero_undef.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.cttz_i64,
                         &[input.into(), is_zero_undef.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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 (v, _) = self.v128_into_i8x16(v, i)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i8x16, &[v.into()], "")
+                    .build_call_with_param_attributes(self.intrinsics.ctpop_i8x16, &[v.into()], "")?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state.push1(res);
+                    .unwrap_basic();
+                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 input = self.apply_pending_canonicalization(input, info)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i32, &[input.into()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.ctpop_i32,
+                        &[input.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Popcnt => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
+                let input = self.apply_pending_canonicalization(input, info)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i64, &[input.into()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.ctpop_i64,
+                        &[input.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             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 = err!(
+                    self.builder
+                        .build_int_z_extend(cond, self.intrinsics.i32_ty, "")
                 );
-                let res = self
-                    .builder
-                    .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 = err!(
+                    self.builder
+                        .build_int_z_extend(cond, self.intrinsics.i32_ty, "")
                 );
-                let res = self
-                    .builder
-                    .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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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
-                    .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, "");
+                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 = 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
-                    .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, "");
+                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_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 +4986,28 @@ 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 =
+                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_add(self.builder.build_int_add(one, v1, ""), v2, "");
-                let res = self.builder.build_right_shift(res, one, false, "");
-                let res = 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 +5023,22 @@ 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 =
+                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_add(self.builder.build_int_add(one, v1, ""), v2, "");
-                let res = self.builder.build_right_shift(res, one, false, "");
-                let res = self
-                    .builder
-                    .build_int_truncate(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                        .build_int_truncate(res, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
 
@@ -4051,8 +5049,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::F32Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.add_f32,
                         &[
                             v1.into(),
@@ -4061,21 +5058,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.add_f64,
                         &[
                             v1.into(),
@@ -4084,22 +5079,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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 (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.add_f32x4,
                         &[
                             v1.into(),
@@ -4108,23 +5101,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.add_f64x2,
                         &[
                             v1.into(),
@@ -4133,22 +5127,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.sub_f32,
                         &[
                             v1.into(),
@@ -4157,21 +5152,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.sub_f64,
                         &[
                             v1.into(),
@@ -4180,22 +5173,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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 (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.sub_f32x4,
                         &[
                             v1.into(),
@@ -4204,23 +5195,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.sub_f64x2,
                         &[
                             v1.into(),
@@ -4229,22 +5221,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.mul_f32,
                         &[
                             v1.into(),
@@ -4253,21 +5246,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.mul_f64,
                         &[
                             v1.into(),
@@ -4276,22 +5267,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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 (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.mul_f32x4,
                         &[
                             v1.into(),
@@ -4300,23 +5289,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.mul_f64x2,
                         &[
                             v1.into(),
@@ -4325,22 +5315,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.div_f32,
                         &[
                             v1.into(),
@@ -4349,18 +5340,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.div_f64,
                         &[
                             v1.into(),
@@ -4369,19 +5358,17 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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 (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.div_f32x4,
                         &[
                             v1.into(),
@@ -4390,20 +5377,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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 (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
                 let res = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.div_f64x2,
                         &[
                             v1.into(),
@@ -4412,1314 +5400,694 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .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()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.sqrt_f32,
+                        &[input.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64Sqrt => {
                 let input = self.state.pop1()?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f64, &[input.into()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.sqrt_f64,
+                        &[input.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4Sqrt => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
+                let (v, _) = self.v128_into_f32x4(v, i)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f32x4, &[v.into()], "")
+                    .build_call_with_param_attributes(self.intrinsics.sqrt_f32x4, &[v.into()], "")?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let bits = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                    .unwrap_basic();
+                let bits = err!(
+                    self.builder
+                        .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 (v, _) = self.v128_into_f64x2(v, i)?;
                 let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f64x2, &[v.into()], "")
+                    .build_call_with_param_attributes(self.intrinsics.sqrt_f64x2, &[v.into()], "")?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let bits = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                    .unwrap_basic();
+                let bits = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "bits")
+                );
                 self.state.push1(bits);
             }
             Operator::F32Min => {
-                // This implements the same logic as LLVM's @llvm.minimum
-                // 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_f32,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f32_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
+                let ((lhs, lhs_info), (rhs, rhs_info)) = self.state.pop2_extra()?;
+                let lhs = self
+                    .apply_pending_canonicalization(lhs, lhs_info)?
+                    .into_float_value();
+                let rhs = self
+                    .apply_pending_canonicalization(rhs, rhs_info)?
+                    .into_float_value();
+
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.minimum_f32,
+                        &[lhs.into(), rhs.into()],
                         "",
-                    )
+                    )?
                     .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,
-                        ],
+                    .unwrap_basic();
+
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_float_value();
+
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Min => {
+                let ((lhs, lhs_info), (rhs, rhs_info)) = self.state.pop2_extra()?;
+                let lhs = self
+                    .apply_pending_canonicalization(lhs, lhs_info)?
+                    .into_float_value();
+                let rhs = self
+                    .apply_pending_canonicalization(rhs, rhs_info)?
+                    .into_float_value();
+
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.minimum_f64,
+                        &[lhs.into(), rhs.into()],
                         "",
-                    )
+                    )?
                     .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,
-                        ],
+                    .unwrap_basic();
+
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_float_value();
+
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32x4Min => {
+                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
+                    .build_call_with_param_attributes(
+                        self.intrinsics.minimum_f32x4,
+                        &[v1.into(), v2.into()],
                         "",
-                    )
+                    )?
                     .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();
+                    .unwrap_basic();
 
-                let res = self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
-                            v1_lt_v2,
-                            v1,
-                            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(),
-                                        "",
-                                    ),
-                                    self.intrinsics.f32_ty,
-                                    "",
-                                ),
-                                "",
-                            ),
-                            "",
-                        ),
-                        "",
-                    ),
-                    "",
-                );
-
-                self.state.push1(res);
-            }
-            Operator::F64Min => {
-                // This implements the same logic as LLVM's @llvm.minimum
-                // 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();
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
-                            v1_lt_v2,
-                            v1,
-                            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(),
-                                        "",
-                                    ),
-                                    self.intrinsics.f64_ty,
-                                    "",
-                                ),
-                                "",
-                            ),
-                            "",
-                        ),
-                        "",
-                    ),
-                    "",
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-
-                self.state.push1(res);
-            }
-            Operator::F32x4Min => {
-                // This implements the same logic as LLVM's @llvm.minimum
-                // 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_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 res = 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,
-                                            "",
-                                        ),
-                                        "",
-                                    ),
-                                    "",
-                                )
-                                .into_vector_value(),
-                            "",
-                        )
-                        .into_vector_value(),
-                    "",
+                self.state.push1_extra(
+                    res,
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
-
-                let res = self.builder.build_bitcast(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
-                    .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, "");
+                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 = 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 => {
-                // This implements the same logic as LLVM's @llvm.minimum
-                // 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_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,
-                        ],
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.minimum_f64x2,
+                        &[v1.into(), v2.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                    .unwrap_basic();
 
-                let res = 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,
-                                            "",
-                                        ),
-                                        "",
-                                    ),
-                                    "",
-                                )
-                                .into_vector_value(),
-                            "",
-                        )
-                        .into_vector_value(),
-                    "",
-                );
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state.push1(res);
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(
+                    res,
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
+                );
             }
             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
-                    .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, "");
+                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_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::F32Max => {
-                // 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_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,
-                        ],
+                let ((lhs, lhs_info), (rhs, rhs_info)) = self.state.pop2_extra()?;
+                let lhs = self
+                    .apply_pending_canonicalization(lhs, lhs_info)?
+                    .into_float_value();
+                let rhs = self
+                    .apply_pending_canonicalization(rhs, rhs_info)?
+                    .into_float_value();
+
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.maximum_f32,
+                        &[lhs.into(), rhs.into()],
                         "",
-                    )
-                    .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();
+                    .unwrap_basic();
 
-                let res = self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
-                            v1_lt_v2,
-                            v2,
-                            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(),
-                                        "",
-                                    ),
-                                    self.intrinsics.f32_ty,
-                                    "",
-                                ),
-                                "",
-                            ),
-                            "",
-                        ),
-                        "",
-                    ),
-                    "",
-                );
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_float_value();
 
-                self.state.push1(res);
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             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,
-                        ],
+                let ((lhs, lhs_info), (rhs, rhs_info)) = self.state.pop2_extra()?;
+                let lhs = self
+                    .apply_pending_canonicalization(lhs, lhs_info)?
+                    .into_float_value();
+                let rhs = self
+                    .apply_pending_canonicalization(rhs, rhs_info)?
+                    .into_float_value();
+
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.maximum_f64,
+                        &[lhs.into(), rhs.into()],
                         "",
-                    )
-                    .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();
+                    .unwrap_basic();
 
-                let res = self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
-                            v1_lt_v2,
-                            v2,
-                            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(),
-                                        "",
-                                    ),
-                                    self.intrinsics.f64_ty,
-                                    "",
-                                ),
-                                "",
-                            ),
-                            "",
-                        ),
-                        "",
-                    ),
-                    "",
-                );
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_float_value();
 
-                self.state.push1(res);
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4Max => {
-                // 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, 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_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,
-                        ],
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = self
+                    .build_call_with_param_attributes(
+                        self.intrinsics.maximum_f32x4,
+                        &[v1.into(), v2.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                    .unwrap_basic();
 
-                let res = 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,
-                                            "",
-                                        ),
-                                        "",
-                                    ),
-                                    "",
-                                )
-                                .into_vector_value(),
-                            "",
-                        )
-                        .into_vector_value(),
-                    "",
-                );
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state.push1(res);
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(
+                    res,
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
+                );
             }
             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
-                    .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, "");
-                self.state.push1(res);
-            }
-            Operator::F64x2Max => {
-                // 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, 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_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,
-                        ],
+                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 = 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::F64x2Max => {
+                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
+                    .build_call_with_param_attributes(
+                        self.intrinsics.maximum_f64x2,
+                        &[v1.into(), v2.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                    .unwrap_basic();
 
-                let res = 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,
-                                            "",
-                                        ),
-                                        "",
-                                    ),
-                                    "",
-                                )
-                                .into_vector_value(),
-                            "",
-                        )
-                        .into_vector_value(),
-                    "",
-                );
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state.push1(res);
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(
+                    res,
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
+                );
             }
             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
-                    .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, "");
+                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 = 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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                self.state
-                    .push1_extra(res, info | ExtraInfo::pending_f32_nan());
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.ceil_f32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.ceil_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F64Ceil => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = 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());
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.ceil_f64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.ceil_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F32Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = 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());
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.floor_f32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.floor_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F64Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = 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());
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.floor_f64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.floor_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F32Trunc => {
-                let (v, i) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f32, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                let (v, info) = self.state.pop1_extra()?;
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.trunc_f32, &[v.into()], "")
+                )
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.trunc_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F64Trunc => {
-                let (v, i) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f64, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                let (v, info) = self.state.pop1_extra()?;
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.trunc_f64, &[v.into()], "")
+                )
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.trunc_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F32Nearest => {
-                let (v, i) = self.state.pop1_extra()?;
-                let res = 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());
+                let (v, info) = self.state.pop1_extra()?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.nearbyint_f32,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.nearbyint_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F64Nearest => {
-                let (v, i) = self.state.pop1_extra()?;
-                let res = 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());
+                let (v, info) = self.state.pop1_extra()?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.nearbyint_f64,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, info)?;
+                self.state.push1_extra(res, info);
             }
             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()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
-                self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res = err!(self.build_call_with_param_attributes(
+                    self.intrinsics.nearbyint_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let (res, info) = self.finalize_rounding_result(res, i)?;
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
+                self.state.push1_extra(res, info);
             }
             Operator::F32Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f32, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                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()
+                .unwrap_basic();
                 // 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
-                    .builder
-                    .build_call(self.intrinsics.fabs_f64, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                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()
+                .unwrap_basic();
                 // 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 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 = self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f32x4, &[v.into()], "")
+                    .build_call_with_param_attributes(self.intrinsics.fabs_f32x4, &[v.into()], "")?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                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 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 = self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f64x2, &[v.into()], "")
+                    .build_call_with_param_attributes(self.intrinsics.fabs_f64x2, &[v.into()], "")?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .unwrap_basic();
+                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 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()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.copysign_f32,
+                        &[mag.into(), sgn.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 // 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 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()], "")
+                    .build_call_with_param_attributes(
+                        self.intrinsics.copysign_f64,
+                        &[mag.into(), sgn.into()],
+                        "",
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 // The exact NaN returned by F32Copysign is fully defined.
                 // Do not adjust.
                 self.state.push1_extra(res, mag_info.strip_pending());
@@ -5731,604 +6099,794 @@ 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
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                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, "")
+                );
                 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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_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_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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_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_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
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                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, "")
+                );
                 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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_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_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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_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_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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::SLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::SLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::SLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_compare(IntPredicate::SLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::ULT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::ULT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::ULT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::ULT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::SLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::SLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::SLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::SLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_compare(IntPredicate::SLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::ULE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::ULE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::ULE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::ULE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::SGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::SGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::SGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_compare(IntPredicate::SGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::UGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::UGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::UGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::UGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::SGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::SGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::SGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::SGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                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_compare(IntPredicate::SGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_int_compare(IntPredicate::UGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                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_compare(IntPredicate::UGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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::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
-                    .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                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_compare(IntPredicate::UGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                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_compare(IntPredicate::UGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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);
             }
 
@@ -6339,241 +6897,313 @@ 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
-                    .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::OEQ, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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::F32Ne | Operator::F64Ne => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
-                    .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::UNE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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::F32Lt | Operator::F64Lt => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::OLT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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::F32Le | Operator::F64Le => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::OLE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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::F32Gt | Operator::F64Gt => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
-                    .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::OGT, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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::F32Ge | Operator::F64Ge => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
-                    .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                let cond = err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::OGE, v1, v2, "")
+                );
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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_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);
             }
 
@@ -6583,35 +7213,38 @@ 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 = v.into_int_value();
-                let res = self
-                    .builder
-                    .build_int_truncate(v, self.intrinsics.i32_ty, "");
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let v = v.into_int_value();
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_s_extend(v, self.intrinsics.i64_ty, "");
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(v, self.intrinsics.i64_ty, "");
+                let res = err!(
+                    self.builder
+                        .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 +7258,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(low, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(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 +7286,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(low, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(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 +7314,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(low, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(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 +7342,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(low, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(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 +7366,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(low, self.intrinsics.i32x4_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(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 +7390,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(low, self.intrinsics.i32x4_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(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 +7414,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(low, self.intrinsics.i32x4_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(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 +7438,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(low, self.intrinsics.i32x4_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
                 self.state.push1(res);
             }
             Operator::I64x2ExtendLowI32x4U
@@ -6807,60 +7472,67 @@ 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 = err!(extend(self, low));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = extend(self, low);
-                let res = self.builder.build_bitcast(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 +7554,59 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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 +7628,60 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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 +7695,59 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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 +7761,57 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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 +7821,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 +7835,41 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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 +7878,12 @@ 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 +7892,40 @@ 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 +7934,12 @@ 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 +7948,40 @@ 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 +7990,12 @@ 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 +8004,40 @@ 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 +8046,12 @@ 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,46 +8060,47 @@ 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.fptrunc_f64,
                         &[
                             v.into(),
@@ -7394,85 +8108,96 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             self.intrinsics.fp_exception_md,
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
+                    .build_call_with_param_attributes(
                         self.intrinsics.fpext_f32,
                         &[v.into(), self.intrinsics.fp_exception_md],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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
-                    .builder
-                    .build_signed_int_to_float(v, self.intrinsics.f32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_signed_int_to_float(
+                    v,
+                    self.intrinsics.f32x4_ty,
+                    ""
+                ));
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_unsigned_int_to_float(v, self.intrinsics.f32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_unsigned_int_to_float(
+                    v,
+                    self.intrinsics.f32x4_ty,
+                    ""
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::F64x2ConvertLowI32x4S | Operator::F64x2ConvertLowI32x4U => {
@@ -7486,8 +8211,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 +8220,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[1],
                     ]),
                     "",
+                ));
+                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_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = extend(self, low);
-                let res = self
-                    .builder
-                    .build_signed_int_to_float(res, self.intrinsics.f64x2_ty, "");
-                let res = self.builder.build_bitcast(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 +8244,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[1],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_float_ext(low, self.intrinsics.f64x2_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self
-                    .builder
-                    .build_float_ext(low, self.intrinsics.f64x2_ty, "");
-                let res = self.builder.build_bitcast(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 +8271,57 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
+                ));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
                 );
-                let res = self.builder.build_bitcast(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);
             }
 
@@ -7594,52 +8331,72 @@ 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, "");
-                let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
+                let extended_value = 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, "");
-                let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
+                let extended_value = 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, "");
-                let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
+                let extended_value = 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, "");
-                let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
+                let extended_value = 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, "");
-                let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
+                let extended_value = err!(self.builder.build_int_s_extend(
+                    narrow_value,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1(extended_value);
             }
 
@@ -7653,13 +8410,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,
                 )?;
-                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 +8433,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,
                 )?;
-                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 +8456,15 @@ 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 +8479,15 @@ 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 +8502,15 @@ 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, "");
+                let result = err!(self.builder.build_load(
+                    self.intrinsics.i128_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7754,19 +8521,21 @@ 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 +8543,30 @@ 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, "");
+                let element = err!(self.builder.build_load(
+                    self.intrinsics.i16_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7800,25 +8574,30 @@ 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, "");
+                let element = err!(self.builder.build_load(
+                    self.intrinsics.i32_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7826,25 +8605,30 @@ 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, "");
+                let element = err!(self.builder.build_load(
+                    self.intrinsics.i64_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7852,8 +8636,11 @@ 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 +8651,22 @@ 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, "");
+                let dead_load = 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 +8676,120 @@ 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, "");
+                let dead_load = 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, "");
+                let dead_load = 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, "");
+                let dead_load = 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, "");
+                let dead_load = 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i8_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7998,26 +8797,28 @@ 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i16_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8025,26 +8826,28 @@ 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i32_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8052,26 +8855,28 @@ 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i64_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8079,8 +8884,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 +8894,26 @@ 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,
+                    ""
+                ));
                 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 +8922,26 @@ 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,
+                    ""
+                ));
                 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,23 +8950,27 @@ 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, "")
-                    .into_int_value();
+                let narrow_result = err!(self.builder.build_load(
+                    self.intrinsics.i8_ty,
+                    effective_address,
+                    ""
+                ))
+                .into_int_value();
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     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,23 +8979,27 @@ 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, "")
-                    .into_int_value();
+                let narrow_result = err!(self.builder.build_load(
+                    self.intrinsics.i16_ty,
+                    effective_address,
+                    ""
+                ))
+                .into_int_value();
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     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 +9008,26 @@ 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, "");
+                let narrow_result = 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 +9037,26 @@ 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,
+                    ""
+                ));
                 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 +9065,26 @@ 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,
+                    ""
+                ));
                 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 +9093,26 @@ 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,
+                    ""
+                ));
                 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 +9121,26 @@ 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,
+                    ""
+                ));
                 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 +9149,26 @@ 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, "");
+                let narrow_result = 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,23 +9179,27 @@ 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i8_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     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);
+                let 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,23 +9209,27 @@ 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, "");
+                let dead_load = err!(self.builder.build_load(
+                    self.intrinsics.i16_ty,
+                    effective_address,
+                    ""
+                ));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     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);
+                let 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,75 +9239,92 @@ 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, "");
+                let dead_load = 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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                let 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 = err!(
+                    self.builder
+                        .build_int_z_extend(res, self.intrinsics.i32_ty, "")
                 );
-                let res = self
-                    .builder
-                    .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 +9339,295 @@ 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 = err!(
+                    self.builder
+                        .build_int_z_extend(res, self.intrinsics.i32_ty, "")
                 );
-                let res = self
-                    .builder
-                    .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
-                    .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                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, "")
+                );
                 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
-                    .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(
+                    self.builder
+                        .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
-                    .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                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, "")
+                );
                 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
-                    .builder
-                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
-                let v2 = self.apply_pending_canonicalization(v2, i2);
-                let v2 = self
-                    .builder
-                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v1 = err!(
+                    self.builder
+                        .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_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
-                    .builder
-                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
-                let v2 = self.apply_pending_canonicalization(v2, i2);
-                let v2 = self
-                    .builder
-                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v1 = err!(
+                    self.builder
+                        .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_bit_cast(v2, self.intrinsics.i8x16_ty, "")
+                )
+                .into_vector_value();
                 let mask = VectorType::const_vector(
                     lanes
                         .iter()
@@ -8776,8 +9635,11 @@ 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 +9648,28 @@ 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.i8_ty.vec_type(8), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(v, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let v = err!(self.builder.build_load(
+                    self.intrinsics.i64_ty,
+                    effective_address,
+                    ""
+                ));
+                let v = err!(
+                    self.builder
+                        .build_bit_cast(v, self.intrinsics.i8_ty.vec_type(8), "")
+                )
+                .into_vector_value();
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(v, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load8x8U { ref memarg } => {
@@ -8809,21 +9678,28 @@ 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.i8_ty.vec_type(8), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_z_extend(v, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let v = err!(self.builder.build_load(
+                    self.intrinsics.i64_ty,
+                    effective_address,
+                    ""
+                ));
+                let v = err!(
+                    self.builder
+                        .build_bit_cast(v, self.intrinsics.i8_ty.vec_type(8), "")
+                )
+                .into_vector_value();
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(v, self.intrinsics.i16x8_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load16x4S { ref memarg } => {
@@ -8832,21 +9708,29 @@ 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), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(v, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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 +9739,29 @@ 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), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_z_extend(v, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .build_int_z_extend(v, self.intrinsics.i32x4_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load32x2S { ref memarg } => {
@@ -8878,21 +9770,29 @@ 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), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(v, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .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 +9801,29 @@ 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), "")
-                    .into_vector_value();
-                let res = self
-                    .builder
-                    .build_int_z_extend(v, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                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 = err!(
+                    self.builder
+                        .build_int_z_extend(v, self.intrinsics.i64x2_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load32Zero { ref memarg } => {
@@ -8924,24 +9832,26 @@ 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 +9860,26 @@ 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 +9888,26 @@ 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 +9916,26 @@ 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 +9944,26 @@ 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 +9972,26 @@ 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 +10009,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 +10031,16 @@ 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 +10053,26 @@ 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, "")
-                    .into_int_value();
+                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 +10081,26 @@ 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, "")
-                    .into_int_value();
+                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 +10109,26 @@ 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, "")
-                    .into_int_value();
+                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 +10137,26 @@ 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, "")
-                    .into_int_value();
+                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 +10165,26 @@ 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, "")
-                    .into_int_value();
+                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 +10194,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 +10212,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 +10230,17 @@ 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_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let 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 +10254,17 @@ 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_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let 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 +10277,17 @@ 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_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let 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 +10300,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9361,9 +10325,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16AddU { ref memarg } => {
@@ -9373,14 +10338,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9396,9 +10363,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwAdd { ref memarg } => {
@@ -9408,11 +10376,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 +10405,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9460,9 +10430,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16AddU { ref memarg } => {
@@ -9472,14 +10443,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9495,9 +10468,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32AddU { ref memarg } => {
@@ -9507,14 +10481,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9530,9 +10506,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwAdd { ref memarg } => {
@@ -9542,11 +10519,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 +10548,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9594,9 +10573,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16SubU { ref memarg } => {
@@ -9606,14 +10586,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9629,9 +10611,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwSub { ref memarg } => {
@@ -9641,11 +10624,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 +10653,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9693,9 +10678,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I64AtomicRmw16SubU { ref memarg } => {
@@ -9705,14 +10691,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9728,9 +10716,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32SubU { ref memarg } => {
@@ -9740,14 +10729,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9763,9 +10754,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwSub { ref memarg } => {
@@ -9775,11 +10767,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 +10796,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9827,9 +10821,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16AndU { ref memarg } => {
@@ -9839,14 +10834,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9862,9 +10859,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwAnd { ref memarg } => {
@@ -9874,11 +10872,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 +10901,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9926,9 +10926,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16AndU { ref memarg } => {
@@ -9938,14 +10939,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9961,9 +10964,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32AndU { ref memarg } => {
@@ -9973,14 +10977,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9996,9 +11002,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwAnd { ref memarg } => {
@@ -10008,11 +11015,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 +11044,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10060,9 +11069,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16OrU { ref memarg } => {
@@ -10072,14 +11082,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10095,9 +11107,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwOr { ref memarg } => {
@@ -10107,11 +11120,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 +11140,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I64AtomicRmw8OrU { ref memarg } => {
@@ -10139,14 +11153,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10162,9 +11178,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16OrU { ref memarg } => {
@@ -10174,14 +11191,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10197,9 +11216,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32OrU { ref memarg } => {
@@ -10209,14 +11229,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10232,9 +11254,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwOr { ref memarg } => {
@@ -10244,11 +11267,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 +11296,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, 2);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10296,9 +11321,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16XorU { ref memarg } => {
@@ -10308,14 +11334,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10331,9 +11359,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwXor { ref memarg } => {
@@ -10343,11 +11372,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 +11401,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10395,9 +11426,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16XorU { ref memarg } => {
@@ -10407,14 +11439,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10430,9 +11464,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32XorU { ref memarg } => {
@@ -10442,14 +11477,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10465,9 +11502,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwXor { ref memarg } => {
@@ -10477,11 +11515,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 +11544,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10529,9 +11569,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16XchgU { ref memarg } => {
@@ -10541,14 +11582,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10564,9 +11607,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwXchg { ref memarg } => {
@@ -10576,11 +11620,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 +11649,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10628,9 +11674,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16XchgU { ref memarg } => {
@@ -10640,14 +11687,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);
-                let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10663,9 +11712,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32XchgU { ref memarg } => {
@@ -10675,14 +11725,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 narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10698,9 +11750,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .build_int_z_extend(old, self.intrinsics.i64_ty, "")
+                );
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwXchg { ref memarg } => {
@@ -10710,11 +11763,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 +11787,29 @@ 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 +11831,37 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .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 +11883,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                let old = err!(
+                    self.builder
+                        .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 +11920,34 @@ 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 +11969,37 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .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 +12021,37 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .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 +12073,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
-                    .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                let old = err!(
+                    self.builder
+                        .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 +12110,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 +12127,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());
+                ));
+                self.state.push1(grow.try_as_basic_value().unwrap_basic());
             }
-            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 +12141,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);
-                self.state.push1(size.try_as_basic_value().left().unwrap());
+                ));
+                //size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
+                self.state.push1(size.try_as_basic_value().unwrap_basic());
             }
             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(
+                self.build_call_with_param_attributes(
                     self.intrinsics.memory_init,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11082,15 +12160,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(
+                self.build_call_with_param_attributes(
                     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 +12184,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(
+                self.build_call_with_param_attributes(
                     memory_copy,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11116,7 +12194,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 +12208,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(
+                self.build_call_with_param_attributes(
                     memory_fill,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11140,23 +12218,25 @@ 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 } => {
@@ -11165,15 +12245,13 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .i32_ty
                     .const_int(function_index.into(), false);
                 let value = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         self.intrinsics.func_ref,
                         &[self.ctx.basic().into(), index.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1(value);
             }
             Operator::TableGet { table } => {
@@ -11189,35 +12267,36 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     self.intrinsics.imported_table_get
                 };
                 let value = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         table_get,
                         &[self.ctx.basic().into(), table_index.into(), elem.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let value = self.builder.build_bitcast(
-                    value,
-                    type_to_llvm(
-                        self.intrinsics,
-                        self.wasm_module
-                            .tables
-                            .get(TableIndex::from_u32(table))
-                            .unwrap()
-                            .ty,
-                    )?,
-                    "",
+                    .unwrap_basic();
+                let value = err!(
+                    self.builder.build_bit_cast(
+                        value,
+                        type_to_llvm(
+                            self.intrinsics,
+                            self.wasm_module
+                                .tables
+                                .get(TableIndex::from_u32(table))
+                                .unwrap()
+                                .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
-                    .builder
-                    .build_bitcast(value, self.intrinsics.anyref_ty, "");
+                let value = err!(
+                    self.builder
+                        .build_bit_cast(value, self.intrinsics.ptr_ty, "")
+                );
                 let table_set = if self
                     .wasm_module
                     .local_table_index(TableIndex::from_u32(table))
@@ -11227,7 +12306,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     self.intrinsics.imported_table_set
                 };
-                self.builder.build_call(
+                self.build_call_with_param_attributes(
                     table_set,
                     &[
                         self.ctx.basic().into(),
@@ -11236,7 +12315,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         value.into(),
                     ],
                     "",
-                );
+                )?;
             }
             Operator::TableCopy {
                 dst_table,
@@ -11245,7 +12324,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(
+                self.build_call_with_param_attributes(
                     self.intrinsics.table_copy,
                     &[
                         self.ctx.basic().into(),
@@ -11256,13 +12335,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(
+                self.build_call_with_param_attributes(
                     self.intrinsics.table_init,
                     &[
                         self.ctx.basic().into(),
@@ -11273,23 +12352,24 @@ 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(
+                self.build_call_with_param_attributes(
                     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
-                    .builder
-                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
-                self.builder.build_call(
+                let elem = err!(
+                    self.builder
+                        .build_bit_cast(elem, self.intrinsics.ptr_ty, "")
+                );
+                self.build_call_with_param_attributes(
                     self.intrinsics.table_fill,
                     &[
                         self.ctx.basic().into(),
@@ -11299,13 +12379,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                )?;
             }
             Operator::TableGrow { table } => {
                 let (elem, delta) = self.state.pop2()?;
-                let elem = self
-                    .builder
-                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
+                let elem = err!(
+                    self.builder
+                        .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))
@@ -11316,8 +12397,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 };
                 let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
                 let size = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         table_grow,
                         &[
                             self.ctx.basic().into(),
@@ -11326,10 +12406,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             table_index.into(),
                         ],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 self.state.push1(size);
             }
             Operator::TableSize { table } => {
@@ -11343,89 +12422,710 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 };
                 let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
                 let size = self
-                    .builder
-                    .build_call(
+                    .build_call_with_param_attributes(
                         table_size,
                         &[self.ctx.basic().into(), table_index.into()],
                         "",
-                    )
+                    )?
                     .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .unwrap_basic();
                 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(
-                    self.intrinsics.memory_wait32_ty,
-                    wait32_fn_ptr,
-                    &[
-                        vmctx.as_basic_value_enum().into(),
-                        self.intrinsics
-                            .i32_ty
-                            .const_int(memarg.memory as u64, false)
-                            .into(),
-                        dst.into(),
-                        val.into(),
-                        timeout.into(),
-                    ],
-                    "",
+                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,
+                        &[
+                            vmctx.as_basic_value_enum().into(),
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(memarg.memory as u64, false)
+                                .into(),
+                            dst.into(),
+                            val.into(),
+                            timeout.into(),
+                        ],
+                        "",
+                    )
                 );
-                self.state.push1(ret.try_as_basic_value().left().unwrap());
+                self.state.push1(ret.try_as_basic_value().unwrap_basic());
             }
             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(
-                    self.intrinsics.memory_wait64_ty,
-                    wait64_fn_ptr,
-                    &[
-                        vmctx.as_basic_value_enum().into(),
-                        self.intrinsics
-                            .i32_ty
-                            .const_int(memarg.memory as u64, false)
-                            .into(),
-                        dst.into(),
-                        val.into(),
-                        timeout.into(),
-                    ],
-                    "",
+                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,
+                        &[
+                            vmctx.as_basic_value_enum().into(),
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(memarg.memory as u64, false)
+                                .into(),
+                            dst.into(),
+                            val.into(),
+                            timeout.into(),
+                        ],
+                        "",
+                    )
                 );
-                self.state.push1(ret.try_as_basic_value().left().unwrap());
+                self.state.push1(ret.try_as_basic_value().unwrap_basic());
             }
             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(
-                    self.intrinsics.memory_notify_ty,
-                    notify_fn_ptr,
-                    &[
-                        vmctx.as_basic_value_enum().into(),
-                        self.intrinsics
-                            .i32_ty
-                            .const_int(memarg.memory as u64, false)
-                            .into(),
-                        dst.into(),
-                        count.into(),
-                    ],
-                    "",
+                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,
+                        &[
+                            vmctx.as_basic_value_enum().into(),
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(memarg.memory as u64, false)
+                                .into(),
+                            dst.into(),
+                            count.into(),
+                        ],
+                        "",
+                    )
+                );
+                self.state.push1(cnt.try_as_basic_value().unwrap_basic());
+            }
+
+            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 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(
+                        self.intrinsics.lpad_exception_ty,
+                        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 selector_value = self.build_call_with_param_attributes(
+                        self.intrinsics.personality2,
+                        &[self.ctx.basic().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()
+                                .unwrap_basic()
+                                .into_int_value(),
+                            catch_specific_block,
+                        ),
+                    ]);
+
+                    // Now we're done looking at the exception, it's time to deallocate and get
+                    // the exnref out of it. When an exception is caught, "rethrowing" simply
+                    // means starting another unwind by calling _Unwind_RaiseException with the
+                    // same exception bits. Instead of keeping the same exception around, we
+                    // deallocate the exception once it's caught, and if we need to rethrow, we
+                    // just re-allocate a new exception.
+                    //
+                    // Note that this is different from how it's done in C++ land, where the
+                    // exception object is kept around for rethrowing; this discrepency exists
+                    // because in C++, exception handling is lexical (i.e. there's an implicit
+                    // "current exception" in catch blocks) whereas in WASM, you rethrow with
+                    // an exnref that may very well have come from somewhere else; consider this
+                    // (badly implemented and erroneous) pseudo-module:
+                    //
+                    // (module
+                    //   (global $e (mut exnref) (ref.null exn))
+                    //   ;; Store the given exnref, return the previous one
+                    //   (func $delay_exnref (param exnref) (result exnref)
+                    //     (global.get $e)
+                    //     (local.get 0)
+                    //     (global.set $e)
+                    //   )
+                    //   (func foo
+                    //     (block $catch (result exnref)
+                    //       (try_table (catch_all_ref $catch)
+                    //         ...
+                    //       )
+                    //     )
+                    //     (call $delay_exnref) ;; store the exnref caught above
+                    //     throw_ref ;; throw the previous exnref
+                    //   )
+                    // )
+                    //
+                    // Here, it's impossible to reuse the same exception object since the
+                    // exnref given to throw_ref is a different one than the one we caught
+                    // with the try_table.
+                    //
+                    // Another difference is that C++ exceptions may well carry lots of data
+                    // around; a WASM exception is just an exnref, backed by a u32, which is
+                    // just 4 bytes, and is cheap to reallocate. C++ exceptions may also carry
+                    // things with dtors around; another thing that doesn't exist in WASM.
+                    //
+                    // All of this is to say that putting exception deallocation and exnref
+                    // retrieval in the same function has been a very deliberate choice.
+                    let uw_exc = uw_exc.into_pointer_value();
+                    let exnref = self.build_call_with_param_attributes(
+                        self.intrinsics.exception_into_exnref,
+                        &[uw_exc.into()],
+                        "exnref",
+                    )?;
+
+                    let exnref = exnref.try_as_basic_value().unwrap_basic().into_int_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));
+                            }
+                            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,
+                                    format!("catch_one_clause_{tag}").as_str(),
+                                );
+                                self.builder.position_at_end(b);
+
+                                let exnref_phi = err!(
+                                    self.builder.build_phi(self.intrinsics.i32_ty, "exnref_phi")
+                                );
+                                exnref_phi.add_incoming(&[(&exnref, catch_end_block)]);
+
+                                // Get the payload pointer.
+                                let exn_payload_ptr = err!(self.builder.build_direct_call(
+                                    self.intrinsics.read_exnref,
+                                    &[self.ctx.basic().into(), exnref_phi.as_basic_value().into()],
+                                    "exn_ptr",
+                                ));
+                                let exn_payload_ptr = exn_payload_ptr
+                                    .try_as_basic_value()
+                                    .unwrap_basic()
+                                    .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!(unsafe {
+                                            self.builder.build_gep(
+                                                self.intrinsics.i128_ty,
+                                                exn_payload_ptr,
+                                                &[self
+                                                    .intrinsics
+                                                    .i32_ty
+                                                    .const_int(i as u64, false)],
+                                                format!("{name}_ptr").as_str(),
+                                            )
+                                        });
+                                        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)?;
+
+                                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(exnref_phi)));
+                            }
+                            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,
+                                    format!("catch_one_ref_clause_{tag}").as_str(),
+                                );
+                                self.builder.position_at_end(b);
+
+                                let exnref_phi = err!(
+                                    self.builder.build_phi(self.intrinsics.i32_ty, "exnref_phi")
+                                );
+                                exnref_phi.add_incoming(&[(&exnref, catch_end_block)]);
+
+                                // Get the payload pointer.
+                                let exn_payload_ptr = err!(self.builder.build_direct_call(
+                                    self.intrinsics.read_exnref,
+                                    &[self.ctx.basic().into(), exnref_phi.as_basic_value().into()],
+                                    "exn_ptr",
+                                ));
+                                let exn_payload_ptr = exn_payload_ptr
+                                    .try_as_basic_value()
+                                    .unwrap_basic()
+                                    .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!(unsafe {
+                                            self.builder.build_gep(
+                                                self.intrinsics.i128_ty,
+                                                exn_payload_ptr,
+                                                &[self
+                                                    .intrinsics
+                                                    .i32_ty
+                                                    .const_int(i as u64, false)],
+                                                format!("{name}_ptr").as_str(),
+                                            )
+                                        });
+                                        err_nt!(self.builder.build_load(
+                                            type_to_llvm(self.intrinsics, *v)?,
+                                            ptr,
+                                            &name,
+                                        ))
+                                    })
+                                    .collect::<Result<Vec<_>, CompileError>>()?;
+
+                                values.push(exnref_phi.as_basic_value());
+
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                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(exnref_phi)));
+                            }
+                            Catch::AllRef { label } => {
+                                let b = self
+                                    .context
+                                    .append_basic_block(self.function, "catch_all_ref_clause");
+                                self.builder.position_at_end(b);
+
+                                let exnref_phi = err!(
+                                    self.builder.build_phi(self.intrinsics.i32_ty, "exnref_phi")
+                                );
+                                exnref_phi.add_incoming(&[(&exnref, catch_end_block)]);
+
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                let phis = frame.phis();
+
+                                assert_eq!(phis.len(), 1);
+                                phis[0].add_incoming(&[(&exnref_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, Some(exnref_phi)));
+                            }
+                        }
+                    }
+
+                    for catch_info in &outer_catch_blocks {
+                        if let Some(phi) = catch_info.exnref_phi {
+                            phi.add_incoming(&[(&exnref, 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);
+
+                    self.build_call_with_param_attributes(
+                        self.intrinsics.throw,
+                        &[self.ctx.basic().into(), exnref.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, exnref_phi))| TagCatchInfo {
+                        tag,
+                        catch_block: block,
+                        exnref_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 sig_index = self.wasm_module.tags[TagIndex::from_u32(tag_index)];
+                let signature = &self.wasm_module.signatures[sig_index];
+                let params = signature.params();
+                let values = self.state.popn_save_extra(params.len())?;
+
+                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(())
+                })?;
+
+                // Allocate the necessary bytes for the exception.
+                let exnref = err!(
+                    self.builder.build_direct_call(
+                        self.intrinsics.alloc_exception,
+                        &[
+                            self.ctx.basic().into(),
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(tag_index as _, false)
+                                .into()
+                        ],
+                        "exnref",
+                    )
                 );
-                self.state.push1(cnt.try_as_basic_value().left().unwrap());
+                let exnref = exnref.try_as_basic_value().unwrap_basic();
+
+                let exn_payload_ptr = err!(self.builder.build_direct_call(
+                    self.intrinsics.read_exnref,
+                    &[self.ctx.basic().into(), exnref.into()],
+                    "exn_ptr",
+                ));
+                let exn_payload_ptr = exn_payload_ptr
+                    .try_as_basic_value()
+                    .unwrap_basic()
+                    .into_pointer_value();
+
+                for (i, value) in values.into_iter().enumerate() {
+                    let ptr = err!(unsafe {
+                        self.builder.build_gep(
+                            self.intrinsics.i128_ty,
+                            exn_payload_ptr,
+                            &[self.intrinsics.i32_ty.const_int(i as u64, false)],
+                            format!("value_{i}_ptr").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.ctx.basic(), exnref],
+                        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 {
+                    self.build_call_with_param_attributes(
+                        self.intrinsics.throw,
+                        &[self.ctx.basic().into(), exnref.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 exnref = 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.throw,
+                        &[self.ctx.basic(), exnref],
+                        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 {
+                    self.build_call_with_param_attributes(
+                        self.intrinsics.throw,
+                        &[self.ctx.basic().into(), exnref.into()],
+                        "throw",
+                    )?;
+                    // 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",
                 )));
             }
         }
 
         Ok(())
     }
+
+    fn build_call_with_param_attributes(
+        &self,
+        function: FunctionValue<'ctx>,
+        args: &[BasicMetadataValueEnum<'ctx>],
+        name: &str,
+    ) -> Result<CallSiteValue<'ctx>, CompileError> {
+        let call = self
+            .builder
+            .build_call(function, args, name)
+            .map_err(|e| CompileError::Codegen(e.to_string()))?;
+
+        // https://five-embeddev.com/riscv-user-isa-manual/Priv-v1.12/rv64.html
+        // > The compiler and calling convention maintain an invariant that all 32-bit values are held in a sign-extended format in 64-bit registers.
+        // > Even 32-bit unsigned integers extend bit 31 into bits 63 through 32. Consequently, conversion between unsigned and signed 32-bit integers
+        // > is a no-op, as is conversion from a signed 32-bit integer to a signed 64-bit integer.
+        if matches!(
+            self.target_triple.architecture,
+            Architecture::Riscv32(..) | Architecture::Riscv64(..)
+        ) {
+            let param_types = function.get_type().get_param_types();
+            for (i, ty) in param_types.into_iter().enumerate() {
+                if ty == self.context.i32_type().into() {
+                    call.add_attribute(
+                        AttributeLoc::Param(i as u32),
+                        self.context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("signext"), 0),
+                    );
+                    call.add_attribute(
+                        AttributeLoc::Param(i as u32),
+                        self.context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("noundef"), 0),
+                    );
+                }
+            }
+        }
+
+        Ok(call)
+    }
 }
 
 fn is_f32_arithmetic(bits: u32) -> bool {
@@ -11439,42 +13139,3 @@ fn is_f64_arithmetic(bits: u64) -> bool {
     let bits = bits & 0x7FFF_FFFF_FFFF_FFFF;
     bits < 0x7FF8_0000_0000_0000
 }
-
-// Constants for the bounds of truncation operations. These are the least or
-// greatest exact floats in either f32 or f64 representation
-// greater-than-or-equal-to (for least) or less-than-or-equal-to (for greatest)
-// the i32 or i64 or u32 or u64 min (for least) or max (for greatest), when
-// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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;
-/// 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..2a0153cb3c 100644
--- a/lib/compiler-llvm/src/translator/intrinsics.rs
+++ b/lib/compiler-llvm/src/translator/intrinsics.rs
@@ -4,9 +4,12 @@
 //!
 //! [llvm-intrinsics]: https://llvm.org/docs/LangRef.html#intrinsic-functions
 
+use crate::LLVM;
 use crate::abi::Abi;
+use crate::error::err;
 use inkwell::values::BasicMetadataValueEnum;
 use inkwell::{
+    AddressSpace,
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     context::Context,
@@ -20,9 +23,9 @@ use inkwell::{
         BasicValue, BasicValueEnum, FloatValue, FunctionValue, InstructionValue, IntValue,
         PointerValue, VectorValue,
     },
-    AddressSpace,
 };
-use std::collections::{hash_map::Entry, HashMap};
+use std::collections::{HashMap, hash_map::Entry};
+use target_lexicon::{Architecture, Triple};
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType as FuncType, GlobalIndex, LocalFunctionIndex,
@@ -32,17 +35,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 +51,13 @@ 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::ExceptionRef => Ok(intrinsics.i32_ty.as_basic_type_enum()),
+        Type::FuncRef | 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>,
@@ -108,6 +105,16 @@ pub struct Intrinsics<'ctx> {
     pub cmp_f32x4: FunctionValue<'ctx>,
     pub cmp_f64x2: FunctionValue<'ctx>,
 
+    pub minimum_f32: FunctionValue<'ctx>,
+    pub minimum_f64: FunctionValue<'ctx>,
+    pub minimum_f32x4: FunctionValue<'ctx>,
+    pub minimum_f64x2: FunctionValue<'ctx>,
+
+    pub maximum_f32: FunctionValue<'ctx>,
+    pub maximum_f64: FunctionValue<'ctx>,
+    pub maximum_f32x4: FunctionValue<'ctx>,
+    pub maximum_f64x2: FunctionValue<'ctx>,
+
     pub ceil_f32: FunctionValue<'ctx>,
     pub ceil_f64: FunctionValue<'ctx>,
     pub ceil_f32x4: FunctionValue<'ctx>,
@@ -156,8 +163,13 @@ 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,
+    // Stack probe function used on Windows MSVC
+    pub chkstk: FunctionValue<'ctx>,
 
     pub void_ty: VoidType<'ctx>,
     pub i1_ty: IntType<'ctx>,
@@ -181,21 +193,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 i1_zero: IntValue<'ctx>,
     pub i8_zero: IntValue<'ctx>,
     pub i32_zero: IntValue<'ctx>,
@@ -254,30 +255,34 @@ pub struct Intrinsics<'ctx> {
 
     pub throw_trap: FunctionValue<'ctx>,
 
+    // EH
+    pub throw: FunctionValue<'ctx>,
+    pub alloc_exception: FunctionValue<'ctx>,
+    pub read_exnref: FunctionValue<'ctx>,
+    pub exception_into_exnref: FunctionValue<'ctx>,
+    pub lpad_exception_ty: StructType<'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,7 +291,10 @@ impl<'ctx> Intrinsics<'ctx> {
         module: &Module<'ctx>,
         context: &'ctx Context,
         target_data: &TargetData,
+        target_triple: &Triple,
+        binary_fmt: &target_lexicon::BinaryFormat,
     ) -> Self {
+        let is_riscv64 = matches!(target_triple.architecture, Architecture::Riscv64(..));
         let void_ty = context.void_type();
         let i1_ty = context.bool_type();
         let i2_ty = context.custom_width_int_type(2);
@@ -311,14 +319,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 +352,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 +365,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 +375,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);
@@ -484,16 +483,46 @@ impl<'ctx> Intrinsics<'ctx> {
             false,
         );
 
+        let add_function_with_attrs =
+            |name: &str, ty: FunctionType<'ctx>, linkage: Option<Linkage>| -> FunctionValue<'ctx> {
+                let function = module.add_function(name, ty, linkage);
+                // https://five-embeddev.com/riscv-user-isa-manual/Priv-v1.12/rv64.html
+                // > The compiler and calling convention maintain an invariant that all 32-bit values are held in a sign-extended format in 64-bit registers.
+                // > Even 32-bit unsigned integers extend bit 31 into bits 63 through 32. Consequently, conversion between unsigned and signed 32-bit integers
+                // > is a no-op, as is conversion from a signed 32-bit integer to a signed 64-bit integer.
+                if is_riscv64 {
+                    for (i, param) in ty.get_param_types().iter().enumerate() {
+                        if param == &i32_ty_basic_md {
+                            function.add_attribute(
+                                AttributeLoc::Param(i as u32),
+                                context.create_enum_attribute(
+                                    Attribute::get_named_enum_kind_id("signext"),
+                                    0,
+                                ),
+                            );
+                            function.add_attribute(
+                                AttributeLoc::Param(i as u32),
+                                context.create_enum_attribute(
+                                    Attribute::get_named_enum_kind_id("noundef"),
+                                    0,
+                                ),
+                            );
+                        }
+                    }
+                }
+                function
+            };
+
         let intrinsics = Self {
-            ctlz_i32: module.add_function("llvm.ctlz.i32", ret_i32_take_i32_i1, None),
-            ctlz_i64: module.add_function("llvm.ctlz.i64", ret_i64_take_i64_i1, None),
+            ctlz_i32: add_function_with_attrs("llvm.ctlz.i32", ret_i32_take_i32_i1, None),
+            ctlz_i64: add_function_with_attrs("llvm.ctlz.i64", ret_i64_take_i64_i1, None),
 
-            cttz_i32: module.add_function("llvm.cttz.i32", ret_i32_take_i32_i1, None),
-            cttz_i64: module.add_function("llvm.cttz.i64", ret_i64_take_i64_i1, None),
+            cttz_i32: add_function_with_attrs("llvm.cttz.i32", ret_i32_take_i32_i1, None),
+            cttz_i64: add_function_with_attrs("llvm.cttz.i64", ret_i64_take_i64_i1, None),
 
-            ctpop_i32: module.add_function("llvm.ctpop.i32", ret_i32_take_i32, None),
-            ctpop_i64: module.add_function("llvm.ctpop.i64", ret_i64_take_i64, None),
-            ctpop_i8x16: module.add_function("llvm.ctpop.v16i8", ret_i8x16_take_i8x16, None),
+            ctpop_i32: add_function_with_attrs("llvm.ctpop.i32", ret_i32_take_i32, None),
+            ctpop_i64: add_function_with_attrs("llvm.ctpop.i64", ret_i64_take_i64, None),
+            ctpop_i8x16: add_function_with_attrs("llvm.ctpop.v16i8", ret_i8x16_take_i8x16, None),
 
             fp_rounding_md: context.metadata_string("round.tonearest").into(),
             fp_exception_md: context.metadata_string("fpexcept.strict").into(),
@@ -502,227 +531,279 @@ impl<'ctx> Intrinsics<'ctx> {
             fp_olt_md: context.metadata_string("olt").into(),
             fp_uno_md: context.metadata_string("uno").into(),
 
-            sqrt_f32: module.add_function("llvm.sqrt.f32", ret_f32_take_f32, None),
-            sqrt_f64: module.add_function("llvm.sqrt.f64", ret_f64_take_f64, None),
-            sqrt_f32x4: module.add_function("llvm.sqrt.v4f32", ret_f32x4_take_f32x4, None),
-            sqrt_f64x2: module.add_function("llvm.sqrt.v2f64", ret_f64x2_take_f64x2, None),
-
-            ceil_f32: module.add_function("llvm.ceil.f32", ret_f32_take_f32, None),
-            ceil_f64: module.add_function("llvm.ceil.f64", ret_f64_take_f64, None),
-            ceil_f32x4: module.add_function("llvm.ceil.v4f32", ret_f32x4_take_f32x4, None),
-            ceil_f64x2: module.add_function("llvm.ceil.v2f64", ret_f64x2_take_f64x2, None),
-
-            floor_f32: module.add_function("llvm.floor.f32", ret_f32_take_f32, None),
-            floor_f64: module.add_function("llvm.floor.f64", ret_f64_take_f64, None),
-            floor_f32x4: module.add_function("llvm.floor.v4f32", ret_f32x4_take_f32x4, None),
-            floor_f64x2: module.add_function("llvm.floor.v2f64", ret_f64x2_take_f64x2, None),
-
-            trunc_f32: module.add_function("llvm.trunc.f32", ret_f32_take_f32, None),
-            trunc_f64: module.add_function("llvm.trunc.f64", ret_f64_take_f64, None),
-            trunc_f32x4: module.add_function("llvm.trunc.v4f32", ret_f32x4_take_f32x4, None),
-            trunc_f64x2: module.add_function("llvm.trunc.v2f64", ret_f64x2_take_f64x2, None),
-
-            nearbyint_f32: module.add_function("llvm.nearbyint.f32", ret_f32_take_f32, None),
-            nearbyint_f64: module.add_function("llvm.nearbyint.f64", ret_f64_take_f64, None),
-            nearbyint_f32x4: module.add_function(
+            sqrt_f32: add_function_with_attrs("llvm.sqrt.f32", ret_f32_take_f32, None),
+            sqrt_f64: add_function_with_attrs("llvm.sqrt.f64", ret_f64_take_f64, None),
+            sqrt_f32x4: add_function_with_attrs("llvm.sqrt.v4f32", ret_f32x4_take_f32x4, None),
+            sqrt_f64x2: add_function_with_attrs("llvm.sqrt.v2f64", ret_f64x2_take_f64x2, None),
+
+            ceil_f32: add_function_with_attrs("llvm.ceil.f32", ret_f32_take_f32, None),
+            ceil_f64: add_function_with_attrs("llvm.ceil.f64", ret_f64_take_f64, None),
+            ceil_f32x4: add_function_with_attrs("llvm.ceil.v4f32", ret_f32x4_take_f32x4, None),
+            ceil_f64x2: add_function_with_attrs("llvm.ceil.v2f64", ret_f64x2_take_f64x2, None),
+
+            floor_f32: add_function_with_attrs("llvm.floor.f32", ret_f32_take_f32, None),
+            floor_f64: add_function_with_attrs("llvm.floor.f64", ret_f64_take_f64, None),
+            floor_f32x4: add_function_with_attrs("llvm.floor.v4f32", ret_f32x4_take_f32x4, None),
+            floor_f64x2: add_function_with_attrs("llvm.floor.v2f64", ret_f64x2_take_f64x2, None),
+
+            trunc_f32: add_function_with_attrs("llvm.trunc.f32", ret_f32_take_f32, None),
+            trunc_f64: add_function_with_attrs("llvm.trunc.f64", ret_f64_take_f64, None),
+            trunc_f32x4: add_function_with_attrs("llvm.trunc.v4f32", ret_f32x4_take_f32x4, None),
+            trunc_f64x2: add_function_with_attrs("llvm.trunc.v2f64", ret_f64x2_take_f64x2, None),
+
+            nearbyint_f32: add_function_with_attrs("llvm.nearbyint.f32", ret_f32_take_f32, None),
+            nearbyint_f64: add_function_with_attrs("llvm.nearbyint.f64", ret_f64_take_f64, None),
+            nearbyint_f32x4: add_function_with_attrs(
                 "llvm.nearbyint.v4f32",
                 ret_f32x4_take_f32x4,
                 None,
             ),
-            nearbyint_f64x2: module.add_function(
+            nearbyint_f64x2: add_function_with_attrs(
                 "llvm.nearbyint.v2f64",
                 ret_f64x2_take_f64x2,
                 None,
             ),
 
-            add_f32: module.add_function(
+            add_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fadd.f32",
                 ret_f32_take_f32_f32_md_md,
                 None,
             ),
-            add_f64: module.add_function(
+            add_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fadd.f64",
                 ret_f64_take_f64_f64_md_md,
                 None,
             ),
-            add_f32x4: module.add_function(
+            add_f32x4: add_function_with_attrs(
                 "llvm.experimental.constrained.fadd.v4f32",
                 ret_f32x4_take_f32x4_f32x4_md_md,
                 None,
             ),
-            add_f64x2: module.add_function(
+            add_f64x2: add_function_with_attrs(
                 "llvm.experimental.constrained.fadd.v2f64",
                 ret_f64x2_take_f64x2_f64x2_md_md,
                 None,
             ),
 
-            sub_f32: module.add_function(
+            sub_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fsub.f32",
                 ret_f32_take_f32_f32_md_md,
                 None,
             ),
-            sub_f64: module.add_function(
+            sub_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fsub.f64",
                 ret_f64_take_f64_f64_md_md,
                 None,
             ),
-            sub_f32x4: module.add_function(
+            sub_f32x4: add_function_with_attrs(
                 "llvm.experimental.constrained.fsub.v4f32",
                 ret_f32x4_take_f32x4_f32x4_md_md,
                 None,
             ),
-            sub_f64x2: module.add_function(
+            sub_f64x2: add_function_with_attrs(
                 "llvm.experimental.constrained.fsub.v2f64",
                 ret_f64x2_take_f64x2_f64x2_md_md,
                 None,
             ),
 
-            mul_f32: module.add_function(
+            mul_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fmul.f32",
                 ret_f32_take_f32_f32_md_md,
                 None,
             ),
-            mul_f64: module.add_function(
+            mul_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fmul.f64",
                 ret_f64_take_f64_f64_md_md,
                 None,
             ),
-            mul_f32x4: module.add_function(
+            mul_f32x4: add_function_with_attrs(
                 "llvm.experimental.constrained.fmul.v4f32",
                 ret_f32x4_take_f32x4_f32x4_md_md,
                 None,
             ),
-            mul_f64x2: module.add_function(
+            mul_f64x2: add_function_with_attrs(
                 "llvm.experimental.constrained.fmul.v2f64",
                 ret_f64x2_take_f64x2_f64x2_md_md,
                 None,
             ),
 
-            div_f32: module.add_function(
+            div_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fdiv.f32",
                 ret_f32_take_f32_f32_md_md,
                 None,
             ),
-            div_f64: module.add_function(
+            div_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fdiv.f64",
                 ret_f64_take_f64_f64_md_md,
                 None,
             ),
-            div_f32x4: module.add_function(
+            div_f32x4: add_function_with_attrs(
                 "llvm.experimental.constrained.fdiv.v4f32",
                 ret_f32x4_take_f32x4_f32x4_md_md,
                 None,
             ),
-            div_f64x2: module.add_function(
+            div_f64x2: add_function_with_attrs(
                 "llvm.experimental.constrained.fdiv.v2f64",
                 ret_f64x2_take_f64x2_f64x2_md_md,
                 None,
             ),
 
-            cmp_f32: module.add_function(
+            cmp_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fcmp.f32",
                 ret_i1_take_f32_f32_md_md,
                 None,
             ),
-            cmp_f64: module.add_function(
+            cmp_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fcmp.f64",
                 ret_i1_take_f64_f64_md_md,
                 None,
             ),
-            cmp_f32x4: module.add_function(
+            cmp_f32x4: add_function_with_attrs(
                 "llvm.experimental.constrained.fcmp.v4f32",
                 ret_i1x4_take_f32x4_f32x4_md_md,
                 None,
             ),
-            cmp_f64x2: module.add_function(
+            cmp_f64x2: add_function_with_attrs(
                 "llvm.experimental.constrained.fcmp.v2f64",
                 ret_i1x2_take_f64x2_f64x2_md_md,
                 None,
             ),
 
-            fpext_f32: module.add_function(
+            minimum_f32: add_function_with_attrs("llvm.minimum.f32", ret_f32_take_f32_f32, None),
+            minimum_f64: add_function_with_attrs("llvm.minimum.f64", ret_f64_take_f64_f64, None),
+            minimum_f32x4: add_function_with_attrs(
+                "llvm.minimum.v4f32",
+                ret_f32x4_take_f32x4_f32x4,
+                None,
+            ),
+            minimum_f64x2: add_function_with_attrs(
+                "llvm.minimum.v2f64",
+                ret_f64x2_take_f64x2_f64x2,
+                None,
+            ),
+
+            maximum_f32: add_function_with_attrs("llvm.maximum.f32", ret_f32_take_f32_f32, None),
+            maximum_f64: add_function_with_attrs("llvm.maximum.f64", ret_f64_take_f64_f64, None),
+            maximum_f32x4: add_function_with_attrs(
+                "llvm.maximum.v4f32",
+                ret_f32x4_take_f32x4_f32x4,
+                None,
+            ),
+            maximum_f64x2: add_function_with_attrs(
+                "llvm.maximum.v2f64",
+                ret_f64x2_take_f64x2_f64x2,
+                None,
+            ),
+
+            fpext_f32: add_function_with_attrs(
                 "llvm.experimental.constrained.fpext.f64.f32",
                 ret_f64_take_f32_md,
                 None,
             ),
-            fptrunc_f64: module.add_function(
+            fptrunc_f64: add_function_with_attrs(
                 "llvm.experimental.constrained.fptrunc.f32.f64",
                 ret_f32_take_f64_md_md,
                 None,
             ),
 
-            fabs_f32: module.add_function("llvm.fabs.f32", ret_f32_take_f32, None),
-            fabs_f64: module.add_function("llvm.fabs.f64", ret_f64_take_f64, None),
-            fabs_f32x4: module.add_function("llvm.fabs.v4f32", ret_f32x4_take_f32x4, None),
-            fabs_f64x2: module.add_function("llvm.fabs.v2f64", ret_f64x2_take_f64x2, None),
+            fabs_f32: add_function_with_attrs("llvm.fabs.f32", ret_f32_take_f32, None),
+            fabs_f64: add_function_with_attrs("llvm.fabs.f64", ret_f64_take_f64, None),
+            fabs_f32x4: add_function_with_attrs("llvm.fabs.v4f32", ret_f32x4_take_f32x4, None),
+            fabs_f64x2: add_function_with_attrs("llvm.fabs.v2f64", ret_f64x2_take_f64x2, None),
 
-            copysign_f32: module.add_function("llvm.copysign.f32", ret_f32_take_f32_f32, None),
-            copysign_f64: module.add_function("llvm.copysign.f64", ret_f64_take_f64_f64, None),
-            copysign_f32x4: module.add_function(
+            copysign_f32: add_function_with_attrs("llvm.copysign.f32", ret_f32_take_f32_f32, None),
+            copysign_f64: add_function_with_attrs("llvm.copysign.f64", ret_f64_take_f64_f64, None),
+            copysign_f32x4: add_function_with_attrs(
                 "llvm.copysign.v4f32",
                 ret_f32x4_take_f32x4_f32x4,
                 None,
             ),
-            copysign_f64x2: module.add_function(
+            copysign_f64x2: add_function_with_attrs(
                 "llvm.copysign.v2f64",
                 ret_f64x2_take_f64x2_f64x2,
                 None,
             ),
 
-            sadd_sat_i8x16: module.add_function(
+            sadd_sat_i8x16: add_function_with_attrs(
                 "llvm.sadd.sat.v16i8",
                 ret_i8x16_take_i8x16_i8x16,
                 None,
             ),
-            sadd_sat_i16x8: module.add_function(
+            sadd_sat_i16x8: add_function_with_attrs(
                 "llvm.sadd.sat.v8i16",
                 ret_i16x8_take_i16x8_i16x8,
                 None,
             ),
-            uadd_sat_i8x16: module.add_function(
+            uadd_sat_i8x16: add_function_with_attrs(
                 "llvm.uadd.sat.v16i8",
                 ret_i8x16_take_i8x16_i8x16,
                 None,
             ),
-            uadd_sat_i16x8: module.add_function(
+            uadd_sat_i16x8: add_function_with_attrs(
                 "llvm.uadd.sat.v8i16",
                 ret_i16x8_take_i16x8_i16x8,
                 None,
             ),
 
-            ssub_sat_i8x16: module.add_function(
+            ssub_sat_i8x16: add_function_with_attrs(
                 "llvm.ssub.sat.v16i8",
                 ret_i8x16_take_i8x16_i8x16,
                 None,
             ),
-            ssub_sat_i16x8: module.add_function(
+            ssub_sat_i16x8: add_function_with_attrs(
                 "llvm.ssub.sat.v8i16",
                 ret_i16x8_take_i16x8_i16x8,
                 None,
             ),
-            usub_sat_i8x16: module.add_function(
+            usub_sat_i8x16: add_function_with_attrs(
                 "llvm.usub.sat.v16i8",
                 ret_i8x16_take_i8x16_i8x16,
                 None,
             ),
-            usub_sat_i16x8: module.add_function(
+            usub_sat_i16x8: add_function_with_attrs(
                 "llvm.usub.sat.v8i16",
                 ret_i16x8_take_i16x8_i16x8,
                 None,
             ),
 
-            expect_i1: module.add_function("llvm.expect.i1", ret_i1_take_i1_i1, None),
-            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),
+            expect_i1: add_function_with_attrs("llvm.expect.i1", ret_i1_take_i1_i1, None),
+            trap: add_function_with_attrs("llvm.trap", void_ty.fn_type(&[], false), None),
+            debug_trap: add_function_with_attrs(
+                "llvm.debugtrap",
+                void_ty.fn_type(&[], false),
+                None,
+            ),
+            personality: add_function_with_attrs(
+                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: add_function_with_attrs(
+                "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"),
+            chkstk: add_function_with_attrs("__chkstk", void_ty.fn_type(&[], false), None),
             void_ty,
             i1_ty,
             i2_ty,
@@ -745,21 +826,7 @@ 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,
-
             i1_zero,
             i8_zero,
             i32_zero,
@@ -800,6 +867,9 @@ impl<'ctx> Intrinsics<'ctx> {
                 .const_int(TrapCode::TableAccessOutOfBounds as _, false)
                 .as_basic_value_enum(),
 
+            // Intentionally don't append any extra attributes:
+            // Attribute 'immarg' is incompatible with other attributes except the 'range' attribute
+            //  ptr @llvm.experimental.stackmap
             experimental_stackmap: module.add_function(
                 "llvm.experimental.stackmap",
                 void_ty.fn_type(
@@ -813,7 +883,7 @@ impl<'ctx> Intrinsics<'ctx> {
             ),
 
             // VM libcalls.
-            table_copy: module.add_function(
+            table_copy: add_function_with_attrs(
                 "wasmer_vm_table_copy",
                 void_ty.fn_type(
                     &[
@@ -828,7 +898,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            table_init: module.add_function(
+            table_init: add_function_with_attrs(
                 "wasmer_vm_table_init",
                 void_ty.fn_type(
                     &[
@@ -843,7 +913,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            table_fill: module.add_function(
+            table_fill: add_function_with_attrs(
                 "wasmer_vm_table_fill",
                 void_ty.fn_type(
                     &[
@@ -857,17 +927,17 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            table_size: module.add_function(
+            table_size: add_function_with_attrs(
                 "wasmer_vm_table_size",
                 i32_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
                 None,
             ),
-            imported_table_size: module.add_function(
+            imported_table_size: add_function_with_attrs(
                 "wasmer_vm_imported_table_size",
                 i32_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
                 None,
             ),
-            table_get: module.add_function(
+            table_get: add_function_with_attrs(
                 "wasmer_vm_table_get",
                 anyref_ty.fn_type(
                     &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
@@ -875,7 +945,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            imported_table_get: module.add_function(
+            imported_table_get: add_function_with_attrs(
                 "wasmer_vm_imported_table_get",
                 anyref_ty.fn_type(
                     &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
@@ -883,7 +953,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            table_set: module.add_function(
+            table_set: add_function_with_attrs(
                 "wasmer_vm_table_set",
                 void_ty.fn_type(
                     &[
@@ -896,7 +966,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            imported_table_set: module.add_function(
+            imported_table_set: add_function_with_attrs(
                 "wasmer_vm_imported_table_set",
                 void_ty.fn_type(
                     &[
@@ -909,7 +979,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            table_grow: module.add_function(
+            table_grow: add_function_with_attrs(
                 "wasmer_vm_table_grow",
                 i32_ty.fn_type(
                     &[
@@ -922,7 +992,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            imported_table_grow: module.add_function(
+            imported_table_grow: add_function_with_attrs(
                 "wasmer_vm_imported_table_grow",
                 i32_ty.fn_type(
                     &[
@@ -935,7 +1005,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            memory_init: module.add_function(
+            memory_init: add_function_with_attrs(
                 "wasmer_vm_memory32_init",
                 void_ty.fn_type(
                     &[
@@ -950,7 +1020,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            memory_copy: module.add_function(
+            memory_copy: add_function_with_attrs(
                 "wasmer_vm_memory32_copy",
                 void_ty.fn_type(
                     &[
@@ -964,7 +1034,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            imported_memory_copy: module.add_function(
+            imported_memory_copy: add_function_with_attrs(
                 "wasmer_vm_imported_memory32_copy",
                 void_ty.fn_type(
                     &[
@@ -978,7 +1048,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            memory_fill: module.add_function(
+            memory_fill: add_function_with_attrs(
                 "wasmer_vm_memory32_fill",
                 void_ty.fn_type(
                     &[
@@ -992,7 +1062,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            imported_memory_fill: module.add_function(
+            imported_memory_fill: add_function_with_attrs(
                 "wasmer_vm_imported_memory32_fill",
                 void_ty.fn_type(
                     &[
@@ -1011,27 +1081,60 @@ impl<'ctx> Intrinsics<'ctx> {
                 &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
                 false,
             ),
-            data_drop: module.add_function(
+            data_drop: add_function_with_attrs(
                 "wasmer_vm_data_drop",
                 void_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
                 None,
             ),
-            func_ref: module.add_function(
+            func_ref: add_function_with_attrs(
                 "wasmer_vm_func_ref",
                 funcref_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
                 None,
             ),
-            elem_drop: module.add_function(
+            elem_drop: add_function_with_attrs(
                 "wasmer_vm_elem_drop",
                 void_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
                 None,
             ),
-            throw_trap: module.add_function(
+            throw_trap: add_function_with_attrs(
                 "wasmer_vm_raise_trap",
                 void_ty.fn_type(&[i32_ty_basic_md], false),
                 None,
             ),
-            memory_wait32: module.add_function(
+
+            throw: add_function_with_attrs(
+                "wasmer_vm_throw",
+                void_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
+            alloc_exception: add_function_with_attrs(
+                "wasmer_vm_alloc_exception",
+                i32_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
+            read_exnref: add_function_with_attrs(
+                "wasmer_vm_read_exnref",
+                ptr_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
+            exception_into_exnref: add_function_with_attrs(
+                "wasmer_vm_exception_into_exnref",
+                i32_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+            lpad_exception_ty: context.struct_type(&[ptr_ty.into(), i32_ty.into()], false),
+
+            debug_ptr: add_function_with_attrs(
+                "wasmer_vm_dbg_usize",
+                void_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+            debug_str: add_function_with_attrs(
+                "wasmer_vm_dbg_str",
+                void_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
+            memory_wait32: add_function_with_attrs(
                 "wasmer_vm_memory32_atomic_wait32",
                 i32_ty.fn_type(
                     &[
@@ -1055,7 +1158,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ],
                 false,
             ),
-            imported_memory_wait32: module.add_function(
+            imported_memory_wait32: add_function_with_attrs(
                 "wasmer_vm_imported_memory32_atomic_wait32",
                 i32_ty.fn_type(
                     &[
@@ -1069,7 +1172,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            memory_wait64: module.add_function(
+            memory_wait64: add_function_with_attrs(
                 "wasmer_vm_memory32_atomic_wait64",
                 i32_ty.fn_type(
                     &[
@@ -1093,7 +1196,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ],
                 false,
             ),
-            imported_memory_wait64: module.add_function(
+            imported_memory_wait64: add_function_with_attrs(
                 "wasmer_vm_imported_memory32_atomic_wait64",
                 i32_ty.fn_type(
                     &[
@@ -1107,7 +1210,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ),
                 None,
             ),
-            memory_notify: module.add_function(
+            memory_notify: add_function_with_attrs(
                 "wasmer_vm_memory32_atomic_notify",
                 i32_ty.fn_type(
                     &[
@@ -1129,7 +1232,7 @@ impl<'ctx> Intrinsics<'ctx> {
                 ],
                 false,
             ),
-            imported_memory_notify: module.add_function(
+            imported_memory_notify: add_function_with_attrs(
                 "wasmer_vm_imported_memory32_atomic_notify",
                 i32_ty.fn_type(
                     &[
@@ -1143,110 +1246,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 +1262,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 +1277,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 +1305,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 +1315,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 +1326,11 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         func_value: &FunctionValue<'ctx>,
         cache_builder: &'a Builder<'ctx>,
         abi: &'a dyn Abi,
+        config: &'a LLVM,
+        pointer_width: u8,
     ) -> CtxType<'ctx, 'a> {
         CtxType {
+            config,
             ctx_ptr_value: abi.get_vmctx_ptr_param(func_value),
 
             wasm_module,
@@ -1334,11 +1342,9 @@ 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),
+            offsets: VMOffsets::new(pointer_width, wasm_module),
         }
     }
 
@@ -1352,7 +1358,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 +1367,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 +1530,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 +1539,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 +1596,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 +1624,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 +1632,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 +1689,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 +1705,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 +1726,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 +1752,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 +1800,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 +1840,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 +2203,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/mod.rs b/lib/compiler-llvm/src/translator/mod.rs
index ac546687d3..1789470525 100644
--- a/lib/compiler-llvm/src/translator/mod.rs
+++ b/lib/compiler-llvm/src/translator/mod.rs
@@ -1,6 +1,5 @@
 mod code;
 pub mod intrinsics;
-//mod stackmap;
 mod state;
 
 pub use self::code::FuncTranslator;
diff --git a/lib/compiler-llvm/src/translator/stackmap.rs b/lib/compiler-llvm/src/translator/stackmap.rs
deleted file mode 100644
index cb6abc48fb..0000000000
--- a/lib/compiler-llvm/src/translator/stackmap.rs
+++ /dev/null
@@ -1,570 +0,0 @@
-// https://llvm.org/docs/StackMaps.html#stackmap-section
-
-use byteorder::{LittleEndian, ReadBytesExt};
-use std::io::{self, Cursor};
-use wasmer_vm_core::vm::Ctx;
-use wasmer_vm_core::{
-    module::Module,
-    structures::TypedIndex,
-    types::{GlobalIndex, LocalOrImport, TableIndex},
-};
-
-#[derive(Default, Debug, Clone)]
-pub struct StackmapRegistry {
-    pub entries: Vec<StackmapEntry>,
-}
-
-#[derive(Debug, Clone)]
-pub struct StackmapEntry {
-    pub kind: StackmapEntryKind,
-    pub local_function_id: usize,
-    pub opcode_offset: usize,
-    pub value_semantics: Vec<ValueSemantic>,
-    pub local_count: usize,
-    pub stack_count: usize,
-    pub is_start: bool,
-}
-
-#[derive(Debug, Clone)]
-pub enum ValueSemantic {
-    WasmLocal(usize),
-    WasmStack(usize),
-    Ctx,
-    SignalMem,
-    PointerToMemoryBase,
-    PointerToMemoryBound, // 64-bit
-    MemoryBase,
-    MemoryBound, // 64-bit
-    PointerToGlobal(usize),
-    Global(usize),
-    PointerToTableBase,
-    PointerToTableBound,
-    ImportedFuncPointer(usize),
-    ImportedFuncCtx(usize),
-    DynamicSigindice(usize),
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum StackmapEntryKind {
-    FunctionHeader,
-    Loop,
-    Call,
-    Trappable,
-}
-
-impl StackmapEntry {
-    #[cfg(all(
-        any(target_os = "freebsd", target_os = "linux", target_vendor = "apple"),
-        target_arch = "x86_64"
-    ))]
-    pub fn populate_msm(
-        &self,
-        module_info: &ModuleInfo,
-        code_addr: usize,
-        llvm_map: &StackMap,
-        size_record: &StkSizeRecord,
-        map_record: &StkMapRecord,
-        end: Option<(&StackmapEntry, &StkMapRecord)>,
-        msm: &mut wasmer_vm_core::state::ModuleStateMap,
-    ) {
-        use std::collections::{BTreeMap, HashMap};
-        use wasmer_vm_core::state::{
-            x64::{new_machine_state, X64Register, GPR},
-            FunctionStateMap, MachineStateDiff, MachineValue, OffsetInfo, RegisterIndex,
-            SuspendOffset, WasmAbstractValue,
-        };
-        use wasmer_vm_core::vm;
-
-        let func_base_addr = (size_record.function_address as usize)
-            .checked_sub(code_addr)
-            .unwrap();
-        let target_offset = func_base_addr + map_record.instruction_offset as usize;
-        assert!(self.is_start);
-
-        if msm.local_functions.len() == self.local_function_id {
-            assert_eq!(self.kind, StackmapEntryKind::FunctionHeader);
-            msm.local_functions.insert(
-                target_offset,
-                FunctionStateMap::new(new_machine_state(), self.local_function_id, 0, vec![]),
-            );
-        } else if msm.local_functions.len() == self.local_function_id + 1 {
-        } else {
-            panic!("unordered local functions");
-        }
-
-        let (_, fsm) = msm.local_functions.iter_mut().last().unwrap();
-
-        assert_eq!(self.value_semantics.len(), map_record.locations.len());
-
-        // System V requires 16-byte alignment before each call instruction.
-        // Considering the saved rbp we need to ensure the stack size % 16 always equals to 8.
-        assert!(size_record.stack_size % 16 == 8);
-
-        // Layout begins just below saved rbp. (push rbp; mov rbp, rsp)
-        let mut machine_stack_half_layout: Vec<MachineValue> =
-            vec![MachineValue::Undefined; (size_record.stack_size - 8) as usize / 4];
-        let mut regs: Vec<(RegisterIndex, MachineValue)> = vec![];
-        let mut stack_constants: HashMap<usize, u64> = HashMap::new();
-
-        let mut prev_frame_diff: BTreeMap<usize, Option<MachineValue>> = BTreeMap::new();
-
-        let mut wasm_locals: Vec<WasmAbstractValue> = vec![];
-        let mut wasm_stack: Vec<WasmAbstractValue> = vec![];
-
-        for (i, loc) in map_record.locations.iter().enumerate() {
-            let mv = match self.value_semantics[i] {
-                ValueSemantic::WasmLocal(x) => {
-                    if x != wasm_locals.len() {
-                        panic!("unordered local values");
-                    }
-                    wasm_locals.push(WasmAbstractValue::Runtime);
-                    MachineValue::WasmLocal(x)
-                }
-                ValueSemantic::WasmStack(x) => {
-                    if x != wasm_stack.len() {
-                        panic!("unordered stack values");
-                    }
-                    wasm_stack.push(WasmAbstractValue::Runtime);
-                    MachineValue::WasmStack(x)
-                }
-                ValueSemantic::Ctx => MachineValue::Vmctx,
-                ValueSemantic::SignalMem => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_interrupt_signal_mem() as usize, 0])
-                }
-                ValueSemantic::PointerToMemoryBase => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_base() as usize])
-                }
-                ValueSemantic::PointerToMemoryBound => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_bound() as usize])
-                }
-                ValueSemantic::MemoryBase => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_base() as usize, 0])
-                }
-                ValueSemantic::MemoryBound => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_bound() as usize, 0])
-                }
-                ValueSemantic::PointerToGlobal(idx) => {
-                    MachineValue::VmctxDeref(deref_global(module_info, idx, false))
-                }
-                ValueSemantic::Global(idx) => {
-                    MachineValue::VmctxDeref(deref_global(module_info, idx, true))
-                }
-                ValueSemantic::PointerToTableBase => {
-                    MachineValue::VmctxDeref(deref_table_base(module_info, 0, false))
-                }
-                ValueSemantic::PointerToTableBound => {
-                    MachineValue::VmctxDeref(deref_table_bound(module_info, 0, false))
-                }
-                ValueSemantic::ImportedFuncPointer(idx) => MachineValue::VmctxDeref(vec![
-                    Ctx::offset_imported_funcs() as usize,
-                    vm::ImportedFunc::size() as usize * idx
-                        + vm::ImportedFunc::offset_func() as usize,
-                    0,
-                ]),
-                ValueSemantic::ImportedFuncCtx(idx) => MachineValue::VmctxDeref(vec![
-                    Ctx::offset_imported_funcs() as usize,
-                    vm::ImportedFunc::size() as usize * idx
-                        + vm::ImportedFunc::offset_func_ctx() as usize,
-                    0,
-                ]),
-                ValueSemantic::DynamicSigindice(idx) => {
-                    MachineValue::VmctxDeref(vec![Ctx::offset_signatures() as usize, idx * 4, 0])
-                }
-            };
-            match loc.ty {
-                LocationType::Register => {
-                    let index = X64Register::from_dwarf_regnum(loc.dwarf_regnum)
-                        .expect("invalid regnum")
-                        .to_index();
-                    regs.push((index, mv));
-                }
-                LocationType::Constant => {
-                    let v = loc.offset_or_small_constant as u32 as u64;
-                    match mv {
-                        MachineValue::WasmStack(x) => {
-                            stack_constants.insert(x, v);
-                            *wasm_stack.last_mut().unwrap() = WasmAbstractValue::Const(v);
-                        }
-                        _ => {} // TODO
-                    }
-                }
-                LocationType::ConstantIndex => {
-                    let v =
-                        llvm_map.constants[loc.offset_or_small_constant as usize].large_constant;
-                    match mv {
-                        MachineValue::WasmStack(x) => {
-                            stack_constants.insert(x, v);
-                            *wasm_stack.last_mut().unwrap() = WasmAbstractValue::Const(v);
-                        }
-                        _ => {} // TODO
-                    }
-                }
-                LocationType::Direct => match mv {
-                    MachineValue::WasmLocal(_) => {
-                        assert_eq!(loc.location_size, 8); // the pointer itself
-                        assert!(
-                            X64Register::from_dwarf_regnum(loc.dwarf_regnum).unwrap()
-                                == X64Register::GPR(GPR::RBP)
-                        );
-                        if loc.offset_or_small_constant >= 0 {
-                            assert!(loc.offset_or_small_constant >= 16); // (saved_rbp, return_address)
-                            assert!(loc.offset_or_small_constant % 8 == 0);
-                            prev_frame_diff
-                                .insert((loc.offset_or_small_constant as usize - 16) / 8, Some(mv));
-                        } else {
-                            let stack_offset = ((-loc.offset_or_small_constant) / 4) as usize;
-                            assert!(
-                                stack_offset > 0 && stack_offset <= machine_stack_half_layout.len()
-                            );
-                            machine_stack_half_layout[stack_offset - 1] = mv;
-                        }
-                    }
-                    _ => unreachable!(
-                        "Direct location type is not expected for values other than local"
-                    ),
-                },
-                LocationType::Indirect => {
-                    assert!(loc.offset_or_small_constant < 0);
-                    assert!(
-                        X64Register::from_dwarf_regnum(loc.dwarf_regnum).unwrap()
-                            == X64Register::GPR(GPR::RBP)
-                    );
-                    let stack_offset = ((-loc.offset_or_small_constant) / 4) as usize;
-                    assert!(stack_offset > 0 && stack_offset <= machine_stack_half_layout.len());
-                    machine_stack_half_layout[stack_offset - 1] = mv;
-                }
-            }
-        }
-
-        assert_eq!(wasm_stack.len(), self.stack_count);
-        assert_eq!(wasm_locals.len(), self.local_count);
-
-        let mut machine_stack_layout: Vec<MachineValue> =
-            Vec::with_capacity(machine_stack_half_layout.len() / 2);
-
-        for i in 0..machine_stack_half_layout.len() / 2 {
-            let major = &machine_stack_half_layout[i * 2 + 1]; // mod 8 == 0
-            let minor = &machine_stack_half_layout[i * 2]; // mod 8 == 4
-            let only_major = match *minor {
-                MachineValue::Undefined => true,
-                _ => false,
-            };
-            if only_major {
-                machine_stack_layout.push(major.clone());
-            } else {
-                machine_stack_layout.push(MachineValue::TwoHalves(Box::new((
-                    major.clone(),
-                    minor.clone(),
-                ))));
-            }
-        }
-
-        let diff = MachineStateDiff {
-            last: None,
-            stack_push: machine_stack_layout,
-            stack_pop: 0,
-            prev_frame_diff,
-            reg_diff: regs,
-            wasm_stack_push: wasm_stack,
-            wasm_stack_pop: 0,
-            wasm_inst_offset: self.opcode_offset,
-        };
-        let diff_id = fsm.diffs.len();
-        fsm.diffs.push(diff);
-
-        match self.kind {
-            StackmapEntryKind::FunctionHeader => {
-                fsm.locals = wasm_locals;
-            }
-            _ => {
-                assert_eq!(fsm.locals, wasm_locals);
-            }
-        }
-
-        let end_offset = {
-            if let Some(end) = end {
-                let (end_entry, end_record) = end;
-                assert_eq!(end_entry.is_start, false);
-                assert_eq!(self.opcode_offset, end_entry.opcode_offset);
-                let end_offset = func_base_addr + end_record.instruction_offset as usize;
-                assert!(end_offset >= target_offset);
-                end_offset
-            } else {
-                target_offset + 1
-            }
-        };
-
-        match self.kind {
-            StackmapEntryKind::Loop => {
-                fsm.wasm_offset_to_target_offset
-                    .insert(self.opcode_offset, SuspendOffset::Loop(target_offset));
-                fsm.loop_offsets.insert(
-                    target_offset,
-                    OffsetInfo {
-                        end_offset,
-                        diff_id,
-                        activate_offset: target_offset,
-                    },
-                );
-            }
-            StackmapEntryKind::Call => {
-                fsm.wasm_offset_to_target_offset
-                    .insert(self.opcode_offset, SuspendOffset::Call(target_offset));
-                fsm.call_offsets.insert(
-                    target_offset,
-                    OffsetInfo {
-                        end_offset: end_offset + 1, // The return address is just after 'call' instruction. Offset by one here.
-                        diff_id,
-                        activate_offset: target_offset,
-                    },
-                );
-            }
-            StackmapEntryKind::Trappable => {
-                fsm.wasm_offset_to_target_offset
-                    .insert(self.opcode_offset, SuspendOffset::Trappable(target_offset));
-                fsm.trappable_offsets.insert(
-                    target_offset,
-                    OffsetInfo {
-                        end_offset,
-                        diff_id,
-                        activate_offset: target_offset,
-                    },
-                );
-            }
-            StackmapEntryKind::FunctionHeader => {
-                fsm.wasm_function_header_target_offset = Some(SuspendOffset::Loop(target_offset));
-                fsm.loop_offsets.insert(
-                    target_offset,
-                    OffsetInfo {
-                        end_offset,
-                        diff_id,
-                        activate_offset: target_offset,
-                    },
-                );
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct StackMap {
-    pub version: u8,
-    pub stk_size_records: Vec<StkSizeRecord>,
-    pub constants: Vec<Constant>,
-    pub stk_map_records: Vec<StkMapRecord>,
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct StkSizeRecord {
-    pub function_address: u64,
-    pub stack_size: u64,
-    pub record_count: u64,
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct Constant {
-    pub large_constant: u64,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct StkMapRecord {
-    pub patchpoint_id: u64,
-    pub instruction_offset: u32,
-    pub locations: Vec<Location>,
-    pub live_outs: Vec<LiveOut>,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Location {
-    pub ty: LocationType,
-    pub location_size: u16,
-    pub dwarf_regnum: u16,
-    pub offset_or_small_constant: i32,
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct LiveOut {
-    pub dwarf_regnum: u16,
-    pub size_in_bytes: u8,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum LocationType {
-    Register,
-    Direct,
-    Indirect,
-    Constant,
-    ConstantIndex,
-}
-
-impl StackMap {
-    pub fn parse(raw: &[u8]) -> io::Result<StackMap> {
-        let mut reader = Cursor::new(raw);
-        let mut map = StackMap::default();
-
-        let version = reader.read_u8()?;
-        if version != 3 {
-            return Err(io::Error::new(io::ErrorKind::Other, "version is not 3"));
-        }
-        map.version = version;
-        if reader.read_u8()? != 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                "reserved field is not zero (1)",
-            ));
-        }
-        if reader.read_u16::<LittleEndian>()? != 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                "reserved field is not zero (2)",
-            ));
-        }
-        let num_functions = reader.read_u32::<LittleEndian>()?;
-        let num_constants = reader.read_u32::<LittleEndian>()?;
-        let num_records = reader.read_u32::<LittleEndian>()?;
-        for _ in 0..num_functions {
-            let mut record = StkSizeRecord::default();
-            record.function_address = reader.read_u64::<LittleEndian>()?;
-            record.stack_size = reader.read_u64::<LittleEndian>()?;
-            record.record_count = reader.read_u64::<LittleEndian>()?;
-            map.stk_size_records.push(record);
-        }
-        for _ in 0..num_constants {
-            map.constants.push(Constant {
-                large_constant: reader.read_u64::<LittleEndian>()?,
-            });
-        }
-        for _ in 0..num_records {
-            let mut record = StkMapRecord::default();
-
-            record.patchpoint_id = reader.read_u64::<LittleEndian>()?;
-            record.instruction_offset = reader.read_u32::<LittleEndian>()?;
-            if reader.read_u16::<LittleEndian>()? != 0 {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "reserved field is not zero (3)",
-                ));
-            }
-            let num_locations = reader.read_u16::<LittleEndian>()?;
-            for _ in 0..num_locations {
-                let ty = reader.read_u8()?;
-
-                let mut location = Location {
-                    ty: match ty {
-                        1 => LocationType::Register,
-                        2 => LocationType::Direct,
-                        3 => LocationType::Indirect,
-                        4 => LocationType::Constant,
-                        5 => LocationType::ConstantIndex,
-                        _ => {
-                            return Err(io::Error::new(
-                                io::ErrorKind::Other,
-                                "unknown location type",
-                            ))
-                        }
-                    },
-                    location_size: 0,
-                    dwarf_regnum: 0,
-                    offset_or_small_constant: 0,
-                };
-
-                if reader.read_u8()? != 0 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "reserved field is not zero (4)",
-                    ));
-                }
-                location.location_size = reader.read_u16::<LittleEndian>()?;
-                location.dwarf_regnum = reader.read_u16::<LittleEndian>()?;
-                if reader.read_u16::<LittleEndian>()? != 0 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "reserved field is not zero (5)",
-                    ));
-                }
-                location.offset_or_small_constant = reader.read_i32::<LittleEndian>()?;
-
-                record.locations.push(location);
-            }
-            if reader.position() % 8 != 0 {
-                if reader.read_u32::<LittleEndian>()? != 0 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "reserved field is not zero (6)",
-                    ));
-                }
-            }
-            if reader.read_u16::<LittleEndian>()? != 0 {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "reserved field is not zero (7)",
-                ));
-            }
-            let num_live_outs = reader.read_u16::<LittleEndian>()?;
-            for _ in 0..num_live_outs {
-                let mut liveout = LiveOut::default();
-
-                liveout.dwarf_regnum = reader.read_u16::<LittleEndian>()?;
-                if reader.read_u8()? != 0 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "reserved field is not zero (8)",
-                    ));
-                }
-                liveout.size_in_bytes = reader.read_u8()?;
-
-                record.live_outs.push(liveout);
-            }
-            if reader.position() % 8 != 0 {
-                if reader.read_u32::<LittleEndian>()? != 0 {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "reserved field is not zero (9)",
-                    ));
-                }
-            }
-
-            map.stk_map_records.push(record);
-        }
-        Ok(map)
-    }
-}
-
-fn deref_global(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
-    let mut x: Vec<usize> = match GlobalIndex::new(idx).local_or_import(info) {
-        LocalOrImport::Local(idx) => vec![Ctx::offset_globals() as usize, idx.index() * 8, 0],
-        LocalOrImport::Import(idx) => {
-            vec![Ctx::offset_imported_globals() as usize, idx.index() * 8, 0]
-        }
-    };
-    if deref_into_value {
-        x.push(0);
-    }
-    x
-}
-
-fn deref_table_base(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
-    let mut x: Vec<usize> = match TableIndex::new(idx).local_or_import(info) {
-        LocalOrImport::Local(idx) => vec![Ctx::offset_tables() as usize, idx.index() * 8, 0],
-        LocalOrImport::Import(idx) => {
-            vec![Ctx::offset_imported_tables() as usize, idx.index() * 8, 0]
-        }
-    };
-    if deref_into_value {
-        x.push(0);
-    }
-    x
-}
-
-fn deref_table_bound(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
-    let mut x: Vec<usize> = match TableIndex::new(idx).local_or_import(info) {
-        LocalOrImport::Local(idx) => vec![Ctx::offset_tables() as usize, idx.index() * 8, 8],
-        LocalOrImport::Import(idx) => {
-            vec![Ctx::offset_imported_tables() as usize, idx.index() * 8, 8]
-        }
-    };
-    if deref_into_value {
-        x.push(0);
-    }
-    x
-}
diff --git a/lib/compiler-llvm/src/translator/state.rs b/lib/compiler-llvm/src/translator/state.rs
index 339d325e71..345009f8c9 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)]
@@ -41,35 +50,36 @@ pub enum IfElseState {
 impl<'ctx> ControlFrame<'ctx> {
     pub fn code_after(&self) -> &BasicBlock<'ctx> {
         match self {
-            ControlFrame::Block { ref next, .. }
-            | ControlFrame::Loop { ref next, .. }
-            | ControlFrame::IfElse { ref next, .. } => next,
+            ControlFrame::Block { next, .. }
+            | ControlFrame::Loop { next, .. }
+            | ControlFrame::Landingpad { next, .. }
+            | ControlFrame::IfElse { next, .. } => next,
         }
     }
 
     pub fn br_dest(&self) -> &BasicBlock<'ctx> {
         match self {
-            ControlFrame::Block { ref next, .. } | ControlFrame::IfElse { ref next, .. } => next,
-            ControlFrame::Loop { ref body, .. } => body,
+            ControlFrame::Block { next, .. }
+            | ControlFrame::IfElse { next, .. }
+            | ControlFrame::Landingpad { next, .. } => next,
+            ControlFrame::Loop { body, .. } => body,
         }
     }
 
     pub fn phis(&self) -> &[PhiValue<'ctx>] {
         match self {
-            ControlFrame::Block { ref phis, .. } | ControlFrame::Loop { ref phis, .. } => {
-                phis.as_slice()
+            ControlFrame::Block { phis, .. } | ControlFrame::Loop { phis, .. } => phis.as_slice(),
+            ControlFrame::IfElse { next_phis, .. } | ControlFrame::Landingpad { next_phis, .. } => {
+                next_phis.as_slice()
             }
-            ControlFrame::IfElse { 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(),
+            ControlFrame::Loop { loop_body_phis, .. } => loop_body_phis.as_slice(),
+            _ => &[],
         }
     }
 
@@ -140,12 +150,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 +173,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 +204,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 +215,31 @@ 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 exnref, if needed; catch_all
+    // blocks don't need the exnref.
+    pub exnref_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 +249,7 @@ impl<'ctx> State<'ctx> {
             stack: vec![],
             control_stack: vec![],
             reachable: true,
+            landingpads: VecDeque::new(),
         }
     }
 
@@ -235,13 +270,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 +431,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 +454,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 +478,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 +487,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..0c1e0f7daa 100644
--- a/lib/compiler-singlepass/Cargo.toml
+++ b/lib/compiler-singlepass/Cargo.toml
@@ -8,29 +8,31 @@ 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 = "=7.0.0", features = ["translator", "compiler"] }
+wasmer-types = { path = "../types", version = "=7.0.0", features = ["std"], default-features = false }
+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.workspace = true
+dynasmrt.workspace = true
+byteorder.workspace = true
+smallvec.workspace = true
+tempfile.workspace = true
+itertools.workspace = true
+target-lexicon.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
 
 [badges]
 maintenance = { status = "actively-developed" }
@@ -43,6 +45,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..955f7c68dc 100644
--- a/lib/compiler-singlepass/README.md
+++ b/lib/compiler-singlepass/README.md
@@ -1,11 +1,15 @@
-# `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.
-
+Supported targets:
+- x86_64
+- aarch64
+- riscv64 (experimental)
 ## 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..7e5505841c 100644
--- a/lib/compiler-singlepass/src/address_map.rs
+++ b/lib/compiler-singlepass/src/address_map.rs
@@ -1,5 +1,6 @@
 use wasmer_compiler::FunctionBodyData;
-use wasmer_types::{FunctionAddressMap, InstructionAddressMap, SourceLoc};
+use wasmer_compiler::types::address_map::{FunctionAddressMap, InstructionAddressMap};
+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..993baf630c 100644
--- a/lib/compiler-singlepass/src/arm64_decl.rs
+++ b/lib/compiler-singlepass/src/arm64_decl.rs
@@ -1,11 +1,51 @@
 //! ARM64 structures.
 
-use crate::common_decl::{MachineState, MachineValue, RegisterIndex};
-use crate::location::CombinedRegister;
-use crate::location::Reg as AbstractReg;
-use std::collections::BTreeMap;
+use crate::location::{CombinedRegister, Reg as AbstractReg};
 use std::slice::Iter;
-use wasmer_types::{CallingConvention, Type};
+use wasmer_types::target::CallingConvention;
+use wasmer_types::{CompileError, Type};
+
+/*
+Register definition: https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#611general-purpose-registers
+
++------+-----------+--------------------------------------------+-------------------+
+| Reg  | ABI Name  | Description                                | Saved by Callee   |
++------+-----------+--------------------------------------------+-------------------+
+| x0   | a0        | argument / return value 0                  | -R                |
+| x1   | a1        | argument / return value 1                  | -R                |
+| x2   | a2        | argument 2                                 | -R                |
+| x3   | a3        | argument 3                                 | -R                |
+| x4   | a4        | argument 4                                 | -R                |
+| x5   | a5        | argument 5                                 | -R                |
+| x6   | a6        | argument 6                                 | -R                |
+| x7   | a7        | argument 7                                 | -R                |
+| x8   | x8 (IP0)  | indirect result / scratch (IP0)            | -R                |
+| x9   | x9 (IP1)  | scratch / intra-proc-call temporary        | -R                |
+| x10  | x10       | scratch / temporary                        | -R                |
+| x11  | x11       | scratch / temporary                        | -R                |
+| x12  | x12       | scratch / temporary                        | -R                |
+| x13  | x13       | scratch / temporary                        | -R                |
+| x14  | x14       | scratch / temporary                        | -R                |
+| x15  | x15       | scratch / temporary                        | -R                |
+| x16  | ip0       | intra-procedure-call scratch (IP0)         | -R                |
+| x17  | ip1       | intra-procedure-call scratch (IP1)         | -R                |
+| x18  | pr        | platform register (varies by OS/platform)  | -                 |
+| x19  | s0        | callee-saved register 0                    | -E                |
+| x20  | s1        | callee-saved register 1                    | -E                |
+| x21  | s2        | callee-saved register 2                    | -E                |
+| x22  | s3        | callee-saved register 3                    | -E                |
+| x23  | s4        | callee-saved register 4                    | -E                |
+| x24  | s5        | callee-saved register 5                    | -E                |
+| x25  | s6        | callee-saved register 6                    | -E                |
+| x26  | s7        | callee-saved register 7                    | -E                |
+| x27  | s8        | callee-saved register 8                    | -E                |
+| x28  | s9        | callee-saved register 9                    | -E                |
+| x29  | fp / s10  | frame pointer / callee-saved register 10   | -E                |
+| x30  | lr        | link register (return address)             | -R                |
+| x31  | sp / wzr  | stack pointer (sp) or zero register (wzr)  | -                 |
++------+-----------+--------------------------------------------+-------------------+
+Legend: -R = caller-saved, -E = callee-saved, - = not saved
+*/
 
 /// General-purpose registers.
 #[repr(u8)]
@@ -46,6 +86,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,13 +132,13 @@ pub enum NEON {
     V31 = 31,
 }
 
-impl AbstractReg for GPR {
-    fn is_callee_save(self) -> bool {
-        self as usize > 18
-    }
-    fn is_reserved(self) -> bool {
-        !matches!(self.into_index(), 0..=16 | 19..=27)
+impl From<NEON> for u8 {
+    fn from(val: NEON) -> Self {
+        val as u8
     }
+}
+
+impl AbstractReg for GPR {
     fn into_index(self) -> usize {
         self as usize
     }
@@ -139,18 +185,48 @@ impl AbstractReg for GPR {
         ];
         GPRS.iter()
     }
-    fn to_dwarf(self) -> u16 {
-        self.into_index() as u16
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::AArch64;
+
+        match self {
+            GPR::X0 => AArch64::X0,
+            GPR::X1 => AArch64::X1,
+            GPR::X2 => AArch64::X2,
+            GPR::X3 => AArch64::X3,
+            GPR::X4 => AArch64::X4,
+            GPR::X5 => AArch64::X5,
+            GPR::X6 => AArch64::X6,
+            GPR::X7 => AArch64::X7,
+            GPR::X8 => AArch64::X8,
+            GPR::X9 => AArch64::X9,
+            GPR::X10 => AArch64::X10,
+            GPR::X11 => AArch64::X11,
+            GPR::X12 => AArch64::X12,
+            GPR::X13 => AArch64::X13,
+            GPR::X14 => AArch64::X14,
+            GPR::X15 => AArch64::X15,
+            GPR::X16 => AArch64::X16,
+            GPR::X17 => AArch64::X17,
+            GPR::X18 => AArch64::X18,
+            GPR::X19 => AArch64::X19,
+            GPR::X20 => AArch64::X20,
+            GPR::X21 => AArch64::X21,
+            GPR::X22 => AArch64::X22,
+            GPR::X23 => AArch64::X23,
+            GPR::X24 => AArch64::X24,
+            GPR::X25 => AArch64::X25,
+            GPR::X26 => AArch64::X26,
+            GPR::X27 => AArch64::X27,
+            GPR::X28 => AArch64::X28,
+            GPR::X29 => AArch64::X29,
+            GPR::X30 => AArch64::X30,
+            GPR::XzrSp => AArch64::SP,
+        }
     }
 }
 
 impl AbstractReg for NEON {
-    fn is_callee_save(self) -> bool {
-        self as usize > 16
-    }
-    fn is_reserved(self) -> bool {
-        false
-    }
     fn into_index(self) -> usize {
         self as usize
     }
@@ -197,8 +273,44 @@ impl AbstractReg for NEON {
         ];
         NEONS.iter()
     }
-    fn to_dwarf(self) -> u16 {
-        self.into_index() as u16 + 64
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::AArch64;
+
+        match self {
+            NEON::V0 => AArch64::V0,
+            NEON::V1 => AArch64::V1,
+            NEON::V2 => AArch64::V2,
+            NEON::V3 => AArch64::V3,
+            NEON::V4 => AArch64::V4,
+            NEON::V5 => AArch64::V5,
+            NEON::V6 => AArch64::V6,
+            NEON::V7 => AArch64::V7,
+            NEON::V8 => AArch64::V8,
+            NEON::V9 => AArch64::V9,
+            NEON::V10 => AArch64::V10,
+            NEON::V11 => AArch64::V11,
+            NEON::V12 => AArch64::V12,
+            NEON::V13 => AArch64::V13,
+            NEON::V14 => AArch64::V14,
+            NEON::V15 => AArch64::V15,
+            NEON::V16 => AArch64::V16,
+            NEON::V17 => AArch64::V17,
+            NEON::V18 => AArch64::V18,
+            NEON::V19 => AArch64::V19,
+            NEON::V20 => AArch64::V20,
+            NEON::V21 => AArch64::V21,
+            NEON::V22 => AArch64::V22,
+            NEON::V23 => AArch64::V23,
+            NEON::V24 => AArch64::V24,
+            NEON::V25 => AArch64::V25,
+            NEON::V26 => AArch64::V26,
+            NEON::V27 => AArch64::V27,
+            NEON::V28 => AArch64::V28,
+            NEON::V29 => AArch64::V29,
+            NEON::V30 => AArch64::V30,
+            NEON::V31 => AArch64::V31,
+        }
     }
 }
 
@@ -213,13 +325,6 @@ pub enum ARM64Register {
 }
 
 impl CombinedRegister for ARM64Register {
-    /// Returns the index of the register.
-    fn to_index(&self) -> RegisterIndex {
-        match *self {
-            ARM64Register::GPR(x) => RegisterIndex(x as usize),
-            ARM64Register::NEON(x) => RegisterIndex(x as usize + 64),
-        }
-    }
     /// Convert from a GPR register
     fn from_gpr(x: u16) -> Self {
         ARM64Register::GPR(GPR::from_index(x as usize).unwrap())
@@ -228,15 +333,6 @@ impl CombinedRegister for ARM64Register {
     fn from_simd(x: u16) -> Self {
         ARM64Register::NEON(NEON::from_index(x as usize).unwrap())
     }
-
-    /// Converts a DWARF regnum to ARM64Register.
-    fn _from_dwarf_regnum(x: u16) -> Option<ARM64Register> {
-        Some(match x {
-            0..=31 => ARM64Register::GPR(GPR::from_index(x as usize).unwrap()),
-            64..=95 => ARM64Register::NEON(NEON::from_index(x as usize - 64).unwrap()),
-            _ => return None,
-        })
-    }
 }
 
 /// An allocator that allocates registers for function arguments according to the System V ABI.
@@ -252,8 +348,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,24 +390,20 @@ 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}"
+                )));
+            }
+        };
 
-/// Create a new `MachineState` with default values.
-pub fn new_machine_state() -> MachineState {
-    MachineState {
-        stack_values: vec![],
-        register_values: vec![MachineValue::Undefined; 32 + 32],
-        prev_frame: BTreeMap::new(),
-        wasm_stack: vec![],
-        wasm_inst_offset: std::usize::MAX,
+        Ok(ret)
     }
 }
diff --git a/lib/compiler-singlepass/src/codegen.rs b/lib/compiler-singlepass/src/codegen.rs
index ab7a783cf4..fd52e67ae1 100644
--- a/lib/compiler-singlepass/src/codegen.rs
+++ b/lib/compiler-singlepass/src/codegen.rs
@@ -1,31 +1,51 @@
-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::{
+        AssemblyComment, FinalizedAssembly, Label, Machine, NATIVE_PAGE_SIZE, UnsignedCondition,
+    },
+    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 itertools::Itertools;
+use smallvec::{SmallVec, smallvec};
+use std::{cmp, collections::HashMap, iter, ops::Neg};
+use target_lexicon::Architecture;
+
+use wasmer_compiler::{
+    FunctionBodyData,
+    misc::CompiledKind,
+    types::{
+        function::{CompiledFunction, CompiledFunctionFrameInfo, FunctionBody},
+        relocation::{Relocation, RelocationTarget},
+        section::SectionIndex,
+    },
+    wasmparser::{
+        BlockType as WpTypeOrFuncType, HeapType as WpHeapType, Operator, RefType as WpRefType,
+        ValType as WpType,
+    },
 };
-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::{
+    CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex,
+    MemoryIndex, MemoryStyle, ModuleInfo, SignatureIndex, TableIndex, TableStyle, TrapCode, Type,
+    VMBuiltinFunctionIndex, VMOffsets,
     entity::{EntityRef, PrimaryMap},
-    CallingConvention, CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex,
-    LocalMemoryIndex, MemoryIndex, MemoryStyle, ModuleInfo, Relocation, RelocationTarget,
-    SectionIndex, SignatureIndex, TableIndex, TableStyle, TrapCode, Type, VMBuiltinFunctionIndex,
-    VMOffsets,
 };
-use wasmer_types::{CompiledFunction, CompiledFunctionFrameInfo, FunctionBody};
+
+#[allow(type_alias_bounds)]
+type LocationWithCanonicalization<M: Machine> = (Location<M::GPR, M::SIMD>, CanonicalizeType);
 
 /// The singlepass per-function code generator.
 pub struct FuncGen<'a, M: Machine> {
@@ -55,21 +75,15 @@ pub struct FuncGen<'a, M: Machine> {
     local_types: Vec<WpType>,
 
     /// Value stack.
-    value_stack: Vec<Location<M::GPR, M::SIMD>>,
-
-    /// Metadata about floating point values on the stack.
-    fp_stack: Vec<FloatValue>,
+    value_stack: Vec<LocationWithCanonicalization<M>>,
 
     /// A list of frames describing the current control stack.
-    control_stack: Vec<ControlFrame>,
-
-    stack_offset: MachineStackOffset,
+    control_stack: Vec<ControlFrame<M>>,
 
-    save_area_offset: Option<MachineStackOffset>,
+    /// Stack offset tracking in bytes.
+    stack_offset: usize,
 
-    state: MachineState,
-
-    track_state: bool,
+    save_area_offset: Option<usize>,
 
     /// Low-level machine state.
     machine: M,
@@ -77,8 +91,8 @@ pub struct FuncGen<'a, M: Machine> {
     /// Nesting level of unreachable code.
     unreachable_depth: usize,
 
-    /// Function state map. Not yet used in the reborn version but let's keep it.
-    fsm: FunctionStateMap,
+    /// Index of a function defined locally inside the WebAssembly module.
+    local_func_index: LocalFunctionIndex,
 
     /// Relocation information.
     relocations: Vec<Relocation>,
@@ -88,6 +102,12 @@ pub struct FuncGen<'a, M: Machine> {
 
     /// Calling convention to use.
     calling_convention: CallingConvention,
+
+    /// Name of the function.
+    function_name: String,
+
+    /// Assembly comments.
+    assembly_comments: HashMap<usize, AssemblyComment>,
 }
 
 struct SpecialLabelSet {
@@ -100,105 +120,38 @@ struct SpecialLabelSet {
     unaligned_atomic: Label,
 }
 
-/// Metadata about a floating-point value.
-#[derive(Copy, Clone, Debug)]
-struct FloatValue {
-    /// Do we need to canonicalize the value before its bit pattern is next observed? If so, how?
-    canonicalization: Option<CanonicalizeType>,
-
-    /// Corresponding depth in the main value stack.
-    depth: usize,
-}
-
-impl FloatValue {
-    fn new(depth: usize) -> Self {
-        FloatValue {
-            canonicalization: None,
-            depth,
-        }
-    }
-
-    fn cncl_f32(depth: usize) -> Self {
-        FloatValue {
-            canonicalization: Some(CanonicalizeType::F32),
-            depth,
-        }
-    }
-
-    fn cncl_f64(depth: usize) -> Self {
-        FloatValue {
-            canonicalization: Some(CanonicalizeType::F64),
-            depth,
-        }
-    }
-
-    fn promote(self, depth: usize) -> Result<FloatValue, CompileError> {
-        let ret = FloatValue {
-            canonicalization: match self.canonicalization {
-                Some(CanonicalizeType::F32) => Some(CanonicalizeType::F64),
-                Some(CanonicalizeType::F64) => codegen_error!("cannot promote F64"),
-                None => None,
-            },
-            depth,
-        };
-        Ok(ret)
-    }
-
-    fn demote(self, depth: usize) -> Result<FloatValue, CompileError> {
-        let ret = FloatValue {
-            canonicalization: match self.canonicalization {
-                Some(CanonicalizeType::F64) => Some(CanonicalizeType::F32),
-                Some(CanonicalizeType::F32) => codegen_error!("cannot demote F32"),
-                None => None,
-            },
-            depth,
-        };
-        Ok(ret)
-    }
-}
-
 /// Type of a pending canonicalization floating point value.
 /// Sometimes we don't have the type information elsewhere and therefore we need to track it here.
 #[derive(Copy, Clone, Debug)]
-enum CanonicalizeType {
+pub(crate) enum CanonicalizeType {
+    None,
     F32,
     F64,
 }
 
 impl CanonicalizeType {
-    fn to_size(self) -> Size {
+    fn to_size(self) -> Option<Size> {
         match self {
-            CanonicalizeType::F32 => Size::S32,
-            CanonicalizeType::F64 => Size::S64,
+            CanonicalizeType::F32 => Some(Size::S32),
+            CanonicalizeType::F64 => Some(Size::S64),
+            CanonicalizeType::None => None,
         }
     }
-}
-
-trait PopMany<T> {
-    fn peek1(&self) -> Result<&T, CompileError>;
-    fn pop1(&mut self) -> Result<T, CompileError>;
-    fn pop2(&mut self) -> Result<(T, T), CompileError>;
-}
 
-impl<T> PopMany<T> for Vec<T> {
-    fn peek1(&self) -> Result<&T, CompileError> {
-        self.last()
-            .ok_or_else(|| CompileError::Codegen("peek1() expects at least 1 element".to_owned()))
-    }
-    fn pop1(&mut self) -> Result<T, CompileError> {
-        self.pop()
-            .ok_or_else(|| CompileError::Codegen("pop1() expects at least 1 element".to_owned()))
-    }
-    fn pop2(&mut self) -> Result<(T, T), CompileError> {
-        if self.len() < 2 {
-            return Err(CompileError::Codegen(
-                "pop2() expects at least 2 elements".to_owned(),
-            ));
+    fn promote(self) -> Result<Self, CompileError> {
+        match self {
+            CanonicalizeType::None => Ok(CanonicalizeType::None),
+            CanonicalizeType::F32 => Ok(CanonicalizeType::F64),
+            CanonicalizeType::F64 => codegen_error!("cannot promote F64"),
         }
+    }
 
-        let right = self.pop().unwrap();
-        let left = self.pop().unwrap();
-        Ok((left, right))
+    fn demote(self) -> Result<Self, CompileError> {
+        match self {
+            CanonicalizeType::None => Ok(CanonicalizeType::None),
+            CanonicalizeType::F32 => codegen_error!("cannot demote F64"),
+            CanonicalizeType::F64 => Ok(CanonicalizeType::F32),
+        }
     }
 }
 
@@ -212,34 +165,60 @@ impl WpTypeExt for WpType {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct ControlFrame {
+#[derive(Clone)]
+pub enum ControlState<M: Machine> {
+    Function,
+    Block,
+    Loop,
+    If {
+        label_else: Label,
+        // Store the input parameters for the If block, as they'll need to be
+        // restored when processing the Else block (if present).
+        inputs: SmallVec<[LocationWithCanonicalization<M>; 1]>,
+    },
+    Else,
+}
+
+#[derive(Clone)]
+struct ControlFrame<M: Machine> {
+    pub state: ControlState<M>,
     pub label: Label,
-    pub loop_like: bool,
-    pub if_else: IfElseState,
-    pub returns: SmallVec<[WpType; 1]>,
-    pub value_stack_depth: usize,
-    pub fp_stack_depth: usize,
-    pub state: MachineState,
-    pub state_diff_id: usize,
+    pub param_types: SmallVec<[WpType; 8]>,
+    pub return_types: SmallVec<[WpType; 1]>,
+    /// Value stack depth at the beginning of the frame (including params and results).
+    value_stack_depth: usize,
 }
 
-#[derive(Debug, Copy, Clone)]
-pub enum IfElseState {
-    None,
-    If(Label),
-    Else,
+impl<M: Machine> ControlFrame<M> {
+    // Get value stack depth at the end of the frame.
+    fn value_stack_depth_after(&self) -> usize {
+        let mut depth: usize = self.value_stack_depth - self.param_types.len();
+
+        // For Loop, we have to use another slot for params that implements the PHI operation.
+        if matches!(self.state, ControlState::Loop) {
+            depth -= self.param_types.len();
+        }
+
+        depth
+    }
+
+    /// Returns the value stack depth at which resources should be deallocated.
+    /// For loops, this preserves PHI arguments by excluding them from deallocation.
+    fn value_stack_depth_for_release(&self) -> usize {
+        self.value_stack_depth - self.param_types.len()
+    }
 }
 
-fn type_to_wp_type(ty: Type) -> WpType {
+fn type_to_wp_type(ty: &Type) -> WpType {
     match ty {
         Type::I32 => WpType::I32,
         Type::I64 => WpType::I64,
         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!(),
     }
 }
 
@@ -251,263 +230,195 @@ struct I2O1<R: Reg, S: Reg> {
     ret: Location<R, S>,
 }
 
-impl<'a, M: Machine> FuncGen<'a, M> {
-    fn get_stack_offset(&self) -> usize {
-        self.stack_offset.0
-    }
+/// Type of native call we emit.
+enum NativeCallType {
+    IncludeVMCtxArgument,
+    Unreachable,
+}
 
-    /// Acquires locations from the machine state.
+impl<'a, M: Machine> FuncGen<'a, M> {
+    /// Acquires location from the machine state.
     ///
-    /// If the returned locations are used for stack value, `release_location` needs to be called on them;
-    /// Otherwise, if the returned locations are used for locals, `release_location` does not need to be called on them.
-    #[allow(clippy::type_complexity)]
-    fn acquire_locations(
-        &mut self,
-        tys: &[(WpType, MachineValue)],
-        zeroed: bool,
-    ) -> Result<SmallVec<[Location<M::GPR, M::SIMD>; 1]>, CompileError> {
-        let mut ret = smallvec![];
-        let mut delta_stack_offset: usize = 0;
-
-        for (ty, mv) in tys {
-            let loc = match *ty {
-                WpType::F32 | WpType::F64 => self.machine.pick_simd().map(Location::SIMD),
-                WpType::I32 | WpType::I64 => self.machine.pick_gpr().map(Location::GPR),
-                WpType::Ref(ty) if ty.is_extern_ref() || ty.is_func_ref() => {
-                    self.machine.pick_gpr().map(Location::GPR)
-                }
-                _ => codegen_error!("can't acquire location for type {:?}", ty),
-            };
+    /// If the returned location is used for stack value, `release_location` needs to be called on it;
+    /// Otherwise, if the returned locations is used for a local, `release_location` does not need to be called on it.
+    fn acquire_location(&mut self, ty: &WpType) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+        let loc = match *ty {
+            WpType::F32 | WpType::F64 => self.machine.pick_simd().map(Location::SIMD),
+            WpType::I32 | WpType::I64 => self.machine.pick_gpr().map(Location::GPR),
+            WpType::Ref(ty) if ty.is_extern_ref() || ty.is_func_ref() => {
+                self.machine.pick_gpr().map(Location::GPR)
+            }
+            _ => codegen_error!("can't acquire location for type {:?}", ty),
+        };
 
-            let loc = if let Some(x) = loc {
-                x
-            } else {
-                self.stack_offset.0 += 8;
-                delta_stack_offset += 8;
-                self.machine.local_on_stack(self.stack_offset.0 as i32)
-            };
-            if let Location::GPR(x) = loc {
-                self.machine.reserve_gpr(x);
-                self.state.register_values[self.machine.index_from_gpr(x).0] = mv.clone();
-            } else if let Location::SIMD(x) = loc {
-                self.machine.reserve_simd(x);
-                self.state.register_values[self.machine.index_from_simd(x).0] = mv.clone();
-            } else {
-                self.state.stack_values.push(mv.clone());
-            }
-            self.state.wasm_stack.push(WasmAbstractValue::Runtime);
-            ret.push(loc);
-        }
+        let Some(loc) = loc else {
+            return self.acquire_location_on_stack();
+        };
 
-        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
-        if delta_stack_offset != 0 {
-            self.machine.adjust_stack(delta_stack_offset as u32)?;
-        }
-        if zeroed {
-            for i in 0..tys.len() {
-                self.machine.zero_location(Size::S64, ret[i])?;
-            }
+        if let Location::GPR(x) = loc {
+            self.machine.reserve_gpr(x);
+        } else if let Location::SIMD(x) = loc {
+            self.machine.reserve_simd(x);
         }
-        Ok(ret)
+        Ok(loc)
+    }
+
+    /// Acquire location that will live on the stack.
+    fn acquire_location_on_stack(&mut self) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+        self.stack_offset += 8;
+        let loc = self.machine.local_on_stack(self.stack_offset as i32);
+        self.machine
+            .extend_stack(self.machine.round_stack_adjust(8) as u32)?;
+
+        Ok(loc)
     }
 
     /// Releases locations used for stack value.
     fn release_locations(
         &mut self,
-        locs: &[Location<M::GPR, M::SIMD>],
+        locs: &[LocationWithCanonicalization<M>],
     ) -> Result<(), CompileError> {
-        let mut delta_stack_offset: usize = 0;
-
-        for loc in locs.iter().rev() {
-            match *loc {
-                Location::GPR(ref x) => {
-                    self.machine.release_gpr(*x);
-                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
-                        MachineValue::Undefined;
-                }
-                Location::SIMD(ref x) => {
-                    self.machine.release_simd(*x);
-                    self.state.register_values[self.machine.index_from_simd(*x).0] =
-                        MachineValue::Undefined;
-                }
-                Location::Memory(y, x) => {
-                    if y == self.machine.local_pointer() {
-                        if x >= 0 {
-                            codegen_error!("Invalid memory offset {}", x);
-                        }
-                        let offset = (-x) as usize;
-                        if offset != self.stack_offset.0 {
-                            codegen_error!(
-                                "Invalid memory offset {}!={}",
-                                offset,
-                                self.stack_offset.0
-                            );
-                        }
-                        self.stack_offset.0 -= 8;
-                        delta_stack_offset += 8;
-                        self.state
-                            .stack_values
-                            .pop()
-                            .ok_or_else(|| CompileError::Codegen("Empty stack_value".to_owned()))?;
-                    }
-                }
-                _ => {}
-            }
-            self.state
-                .wasm_stack
-                .pop()
-                .ok_or_else(|| CompileError::Codegen("Pop with wasm stack empty".to_owned()))?;
-        }
-        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
-        if delta_stack_offset != 0 {
-            self.machine.restore_stack(delta_stack_offset as u32)?;
-        }
-        Ok(())
+        self.release_stack_locations(locs)?;
+        self.release_reg_locations(locs)
     }
-    /// Releases locations used for stack value.
-    fn release_locations_value(&mut self, stack_depth: usize) -> Result<(), CompileError> {
-        let mut delta_stack_offset: usize = 0;
-        let locs: &[Location<M::GPR, M::SIMD>] = &self.value_stack[stack_depth..];
 
-        for loc in locs.iter().rev() {
+    fn release_reg_locations(
+        &mut self,
+        locs: &[LocationWithCanonicalization<M>],
+    ) -> Result<(), CompileError> {
+        for (loc, _) in locs.iter().rev() {
             match *loc {
                 Location::GPR(ref x) => {
                     self.machine.release_gpr(*x);
-                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
-                        MachineValue::Undefined;
                 }
                 Location::SIMD(ref x) => {
                     self.machine.release_simd(*x);
-                    self.state.register_values[self.machine.index_from_simd(*x).0] =
-                        MachineValue::Undefined;
-                }
-                Location::Memory(y, x) => {
-                    if y == self.machine.local_pointer() {
-                        if x >= 0 {
-                            codegen_error!("Invalid memory offset {}", x);
-                        }
-                        let offset = (-x) as usize;
-                        if offset != self.stack_offset.0 {
-                            codegen_error!(
-                                "Invalid memory offset {}!={}",
-                                offset,
-                                self.stack_offset.0
-                            );
-                        }
-                        self.stack_offset.0 -= 8;
-                        delta_stack_offset += 8;
-                        self.state.stack_values.pop().ok_or_else(|| {
-                            CompileError::Codegen("Pop with values stack empty".to_owned())
-                        })?;
-                    }
                 }
                 _ => {}
             }
-            self.state
-                .wasm_stack
-                .pop()
-                .ok_or_else(|| CompileError::Codegen("Pop with wasm stack empty".to_owned()))?;
-        }
-
-        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
-        if delta_stack_offset != 0 {
-            self.machine.adjust_stack(delta_stack_offset as u32)?;
         }
         Ok(())
     }
 
-    fn release_locations_only_regs(
+    fn release_stack_locations(
         &mut self,
-        locs: &[Location<M::GPR, M::SIMD>],
+        locs: &[LocationWithCanonicalization<M>],
     ) -> Result<(), CompileError> {
-        for loc in locs.iter().rev() {
-            match *loc {
-                Location::GPR(ref x) => {
-                    self.machine.release_gpr(*x);
-                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
-                        MachineValue::Undefined;
-                }
-                Location::SIMD(ref x) => {
-                    self.machine.release_simd(*x);
-                    self.state.register_values[self.machine.index_from_simd(*x).0] =
-                        MachineValue::Undefined;
-                }
-                _ => {}
+        for (loc, _) in locs.iter().rev() {
+            if let Location::Memory(..) = *loc {
+                self.check_location_on_stack(loc, self.stack_offset)?;
+                self.stack_offset -= 8;
+                self.machine
+                    .truncate_stack(self.machine.round_stack_adjust(8) as u32)?;
             }
-            // Wasm state popping is deferred to `release_locations_only_osr_state`.
         }
+
         Ok(())
     }
 
-    fn release_locations_only_stack(
+    fn release_stack_locations_keep_stack_offset(
         &mut self,
-        locs: &[Location<M::GPR, M::SIMD>],
+        stack_depth: usize,
     ) -> Result<(), CompileError> {
-        let mut delta_stack_offset: usize = 0;
+        let mut stack_offset = self.stack_offset;
+        let locs = &self.value_stack[stack_depth..];
 
-        for loc in locs.iter().rev() {
-            if let Location::Memory(y, x) = *loc {
-                if y == self.machine.local_pointer() {
-                    if x >= 0 {
-                        codegen_error!("Invalid memory offset {}", x);
-                    }
-                    let offset = (-x) as usize;
-                    if offset != self.stack_offset.0 {
-                        codegen_error!("Invalid memory offset {}!={}", offset, self.stack_offset.0);
-                    }
-                    self.stack_offset.0 -= 8;
-                    delta_stack_offset += 8;
-                    self.state.stack_values.pop().ok_or_else(|| {
-                        CompileError::Codegen("Pop on empty value stack".to_owned())
-                    })?;
-                }
+        for (loc, _) in locs.iter().rev() {
+            if let Location::Memory(..) = *loc {
+                self.check_location_on_stack(loc, stack_offset)?;
+                stack_offset -= 8;
+                self.machine
+                    .truncate_stack(self.machine.round_stack_adjust(8) as u32)?;
             }
-            // Wasm state popping is deferred to `release_locations_only_osr_state`.
         }
 
-        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
-        if delta_stack_offset != 0 {
-            self.machine.pop_stack_locals(delta_stack_offset as u32)?;
-        }
         Ok(())
     }
 
-    fn release_locations_only_osr_state(&mut self, n: usize) -> Result<(), CompileError> {
-        let new_length = self
-            .state
-            .wasm_stack
-            .len()
-            .checked_sub(n)
-            .expect("release_locations_only_osr_state: length underflow");
-        self.state.wasm_stack.truncate(new_length);
+    fn check_location_on_stack(
+        &self,
+        loc: &Location<M::GPR, M::SIMD>,
+        expected_stack_offset: usize,
+    ) -> Result<(), CompileError> {
+        let Location::Memory(reg, offset) = loc else {
+            codegen_error!("Expected stack memory location");
+        };
+        if reg != &self.machine.local_pointer() {
+            codegen_error!("Expected location pointer for value on stack");
+        }
+        if *offset >= 0 {
+            codegen_error!("Invalid memory offset {offset}");
+        }
+        let offset = offset.neg() as usize;
+        if offset != expected_stack_offset {
+            codegen_error!("Invalid memory offset {offset}!={}", self.stack_offset);
+        }
         Ok(())
     }
 
-    fn release_locations_keep_state(&mut self, stack_depth: usize) -> Result<(), CompileError> {
-        let mut delta_stack_offset: usize = 0;
-        let mut stack_offset = self.stack_offset.0;
-        let locs = &self.value_stack[stack_depth..];
+    /// Allocate return slots for block operands (Block, If, Loop) and swap them with
+    /// the corresponding input parameters on the value stack.
+    ///
+    /// This method reserves memory slots that can accommodate both integer and
+    /// floating-point types, then swaps these slots with the last `stack_slots`
+    /// values on the stack to position them correctly for the block's return values.
+    /// that are already present at the value stack.
+    fn allocate_return_slots_and_swap(
+        &mut self,
+        stack_slots: usize,
+        return_slots: usize,
+    ) -> Result<(), CompileError> {
+        // No shuffling needed.
+        if return_slots == 0 {
+            return Ok(());
+        }
 
-        for loc in locs.iter().rev() {
-            if let Location::Memory(y, x) = *loc {
-                if y == self.machine.local_pointer() {
-                    if x >= 0 {
-                        codegen_error!("Invalid memory offset {}", x);
-                    }
-                    let offset = (-x) as usize;
-                    if offset != stack_offset {
-                        codegen_error!("Invalid memory offset {}!={}", offset, self.stack_offset.0);
-                    }
-                    stack_offset -= 8;
-                    delta_stack_offset += 8;
+        /* To allocate N return slots, we first allocate N additional stack (memory) slots and then "shift" the
+        existing stack slots. This results in the layout: [value stack before frame, ret0, ret1, ret2, ..., retN, arg0, arg1, ..., argN],
+        where some of the argN values may reside in registers and others in memory on the stack. */
+        let latest_slots = self
+            .value_stack
+            .drain(self.value_stack.len() - stack_slots..)
+            .collect_vec();
+        let extra_slots = (0..return_slots)
+            .map(|_| self.acquire_location_on_stack())
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let mut all_memory_slots = latest_slots
+            .iter()
+            .filter_map(|(loc, _)| {
+                if let Location::Memory(..) = loc {
+                    Some(loc)
+                } else {
+                    None
                 }
-            }
-        }
+            })
+            .chain(extra_slots.iter())
+            .collect_vec();
 
-        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
-        if delta_stack_offset != 0 {
-            self.machine.pop_stack_locals(delta_stack_offset as u32)?;
+        // First put the newly allocated return values to the value stack.
+        self.value_stack.extend(
+            all_memory_slots
+                .iter()
+                .take(return_slots)
+                .map(|loc| (**loc, CanonicalizeType::None)),
+        );
+
+        // Then map all memory stack slots to a new location (in reverse order).
+        let mut new_params_reversed = Vec::new();
+        for (loc, canonicalize) in latest_slots.iter().rev() {
+            let mapped_loc = if matches!(loc, Location::Memory(..)) {
+                let dest = all_memory_slots.pop().unwrap();
+                self.machine.emit_relaxed_mov(Size::S64, *loc, *dest)?;
+                *dest
+            } else {
+                *loc
+            };
+            new_params_reversed.push((mapped_loc, *canonicalize));
         }
+        self.value_stack
+            .extend(new_params_reversed.into_iter().rev());
+
         Ok(())
     }
 
@@ -518,6 +429,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         sig: FunctionType,
         calling_convention: CallingConvention,
     ) -> Result<Vec<Location<M::GPR, M::SIMD>>, CompileError> {
+        self.add_assembly_comment(AssemblyComment::InitializeLocals);
+
         // How many machine stack slots will all the locals use?
         let num_mem_slots = (0..n)
             .filter(|&x| self.machine.is_local_on_stack(x))
@@ -567,52 +480,32 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             self.machine.zero_location(Size::S64, locations[i])?;
         }
 
-        self.machine.adjust_stack(static_area_size as _)?;
+        self.machine.extend_stack(static_area_size as _)?;
 
         // Save callee-saved registers.
         for loc in locations.iter() {
-            if let Location::GPR(x) = *loc {
-                self.stack_offset.0 += 8;
-                self.machine.move_local(self.stack_offset.0 as i32, *loc)?;
-                self.state.stack_values.push(MachineValue::PreserveRegister(
-                    self.machine.index_from_gpr(x),
-                ));
+            if let Location::GPR(_) = *loc {
+                self.stack_offset += 8;
+                self.machine.move_local(self.stack_offset as i32, *loc)?;
             }
         }
 
         // Save the Reg use for vmctx.
-        self.stack_offset.0 += 8;
+        self.stack_offset += 8;
         self.machine.move_local(
-            self.stack_offset.0 as i32,
+            self.stack_offset as i32,
             Location::GPR(self.machine.get_vmctx_reg()),
         )?;
-        self.state.stack_values.push(MachineValue::PreserveRegister(
-            self.machine.index_from_gpr(self.machine.get_vmctx_reg()),
-        ));
 
         // Check if need to same some CallingConvention specific regs
         let regs_to_save = self.machine.list_to_save(calling_convention);
         for loc in regs_to_save.iter() {
-            self.stack_offset.0 += 8;
-            self.machine.move_local(self.stack_offset.0 as i32, *loc)?;
+            self.stack_offset += 8;
+            self.machine.move_local(self.stack_offset as i32, *loc)?;
         }
 
         // Save the offset of register save area.
-        self.save_area_offset = Some(MachineStackOffset(self.stack_offset.0));
-
-        // Save location information for locals.
-        for (i, loc) in locations.iter().enumerate() {
-            match *loc {
-                Location::GPR(x) => {
-                    self.state.register_values[self.machine.index_from_gpr(x).0] =
-                        MachineValue::WasmLocal(i);
-                }
-                Location::Memory(_, _) => {
-                    self.state.stack_values.push(MachineValue::WasmLocal(i));
-                }
-                _ => codegen_error!("singlpass init_local unreachable"),
-            }
-        }
+        self.save_area_offset = Some(self.stack_offset);
 
         // Load in-register parameters into the allocated locations.
         // Locals are allocated on the stack from higher address to lower address,
@@ -623,9 +516,12 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 Type::I32 | Type::F32 => Size::S32,
                 Type::I64 | Type::F64 => Size::S64,
                 Type::ExternRef | Type::FuncRef => Size::S64,
-                _ => codegen_error!("singlepass init_local unimplemented"),
+                _ => {
+                    codegen_error!("singlepass init_local unimplemented type: {param}")
+                }
             };
             let loc = self.machine.get_call_param_location(
+                sig.results().len(),
                 i + 1,
                 sz,
                 &mut stack_offset,
@@ -638,8 +534,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         // Load vmctx into it's GPR.
         self.machine.move_location(
             Size::S64,
-            self.machine
-                .get_simple_param_location(0, calling_convention),
+            Location::GPR(
+                self.machine
+                    .get_simple_param_location(0, calling_convention),
+            ),
             Location::GPR(self.machine.get_vmctx_reg()),
         )?;
 
@@ -664,7 +562,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         }
 
         // Add the size of all locals allocated to stack.
-        self.stack_offset.0 += static_area_size - callee_saved_regs_size;
+        self.stack_offset += static_area_size - callee_saved_regs_size;
 
         Ok(locations)
     }
@@ -675,7 +573,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
     ) -> Result<(), CompileError> {
         // Unwind stack to the "save area".
         self.machine
-            .restore_saved_area(self.save_area_offset.as_ref().unwrap().0 as i32)?;
+            .restore_saved_area(self.save_area_offset.unwrap() as i32)?;
 
         let regs_to_save = self.machine.list_to_save(calling_convention);
         for loc in regs_to_save.iter().rev() {
@@ -702,121 +600,100 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
     fn get_location_released(
         &mut self,
-        loc: Location<M::GPR, M::SIMD>,
-    ) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+        loc: (Location<M::GPR, M::SIMD>, CanonicalizeType),
+    ) -> Result<LocationWithCanonicalization<M>, CompileError> {
         self.release_locations(&[loc])?;
         Ok(loc)
     }
 
-    fn pop_value_released(&mut self) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+    fn pop_value_released(&mut self) -> Result<LocationWithCanonicalization<M>, CompileError> {
         let loc = self.value_stack.pop().ok_or_else(|| {
             CompileError::Codegen("pop_value_released: value stack is empty".to_owned())
         })?;
-        self.get_location_released(loc)
+        self.get_location_released(loc)?;
+        Ok(loc)
     }
 
     /// Prepare data for binary operator with 2 inputs and 1 output.
-    fn i2o1_prepare(&mut self, ty: WpType) -> Result<I2O1<M::GPR, M::SIMD>, CompileError> {
-        let loc_b = self.pop_value_released()?;
-        let loc_a = self.pop_value_released()?;
-        let ret = self.acquire_locations(
-            &[(ty, MachineValue::WasmStack(self.value_stack.len()))],
-            false,
-        )?[0];
-        self.value_stack.push(ret);
+    fn i2o1_prepare(
+        &mut self,
+        ty: WpType,
+        canonicalize: CanonicalizeType,
+    ) -> Result<I2O1<M::GPR, M::SIMD>, CompileError> {
+        let loc_b = self.pop_value_released()?.0;
+        let loc_a = self.pop_value_released()?.0;
+        let ret = self.acquire_location(&ty)?;
+        self.value_stack.push((ret, canonicalize));
         Ok(I2O1 { loc_a, loc_b, ret })
     }
 
-    fn mark_trappable(&mut self) {
-        let state_diff_id = self.get_state_diff();
-        let offset = self.machine.assembler_get_offset().0;
-        self.fsm.trappable_offsets.insert(
-            offset,
-            OffsetInfo {
-                end_offset: offset + 1,
-                activate_offset: offset,
-                diff_id: state_diff_id,
-            },
-        );
-        self.fsm.wasm_offset_to_target_offset.insert(
-            self.state.wasm_inst_offset,
-            SuspendOffset::Trappable(offset),
-        );
-    }
-    fn mark_offset_trappable(&mut self, offset: usize) {
-        let state_diff_id = self.get_state_diff();
-        self.fsm.trappable_offsets.insert(
-            offset,
-            OffsetInfo {
-                end_offset: offset + 1,
-                activate_offset: offset,
-                diff_id: state_diff_id,
-            },
-        );
-        self.fsm.wasm_offset_to_target_offset.insert(
-            self.state.wasm_inst_offset,
-            SuspendOffset::Trappable(offset),
-        );
-    }
-
     /// Emits a Native ABI call sequence.
     ///
     /// The caller MUST NOT hold any temporary registers allocated by `acquire_temp_gpr` when calling
     /// this function.
     fn emit_call_native<
-        I: Iterator<Item = Location<M::GPR, M::SIMD>>,
+        I: Iterator<Item = (Location<M::GPR, M::SIMD>, CanonicalizeType)>,
         J: Iterator<Item = WpType>,
+        K: Iterator<Item = WpType>,
         F: FnOnce(&mut Self) -> Result<(), CompileError>,
     >(
         &mut self,
         cb: F,
         params: I,
         params_type: J,
+        return_types: K,
+        call_type: NativeCallType,
     ) -> Result<(), CompileError> {
-        // Values pushed in this function are above the shadow region.
-        self.state.stack_values.push(MachineValue::ExplicitShadow);
-
-        let params: Vec<_> = params.collect();
-        let params_size: Vec<_> = params_type
-            .map(|x| match x {
-                WpType::F32 | WpType::I32 => Size::S32,
-                WpType::V128 => unimplemented!(),
-                _ => Size::S64,
+        let params = params.collect_vec();
+        let stack_params = params
+            .iter()
+            .copied()
+            .filter(|(param, _)| {
+                if let Location::Memory(reg, _) = param {
+                    debug_assert_eq!(reg, &self.machine.local_pointer());
+                    true
+                } else {
+                    false
+                }
             })
-            .collect();
+            .collect_vec();
+        let get_size = |param_type: WpType| match param_type {
+            WpType::F32 | WpType::I32 => Size::S32,
+            WpType::V128 => unimplemented!(),
+            _ => Size::S64,
+        };
+        let param_sizes = params_type.map(get_size).collect_vec();
+        let return_value_sizes = return_types.map(get_size).collect_vec();
+
+        /* We're going to reuse the memory param locations for the return values. Any extra needed slots will be allocated on stack. */
+        let used_stack_params = stack_params
+            .iter()
+            .take(return_value_sizes.len())
+            .copied()
+            .collect_vec();
+        let mut return_values = used_stack_params.clone();
+        let extra_return_values = (0..return_value_sizes.len().saturating_sub(stack_params.len()))
+            .map(|_| -> Result<_, CompileError> {
+                Ok((self.acquire_location_on_stack()?, CanonicalizeType::None))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        return_values.extend(extra_return_values);
+
+        // Release the parameter slots that live in registers.
+        self.release_reg_locations(&params)?;
 
         // Save used GPRs. Preserve correct stack alignment
         let used_gprs = self.machine.get_used_gprs();
         let mut used_stack = self.machine.push_used_gpr(&used_gprs)?;
-        for r in used_gprs.iter() {
-            let content = self.state.register_values[self.machine.index_from_gpr(*r).0].clone();
-            if content == MachineValue::Undefined {
-                return Err(CompileError::Codegen(
-                    "emit_call_native: Undefined used_gprs content".to_owned(),
-                ));
-            }
-            self.state.stack_values.push(content);
-        }
 
         // Save used SIMD registers.
         let used_simds = self.machine.get_used_simd();
         if !used_simds.is_empty() {
             used_stack += self.machine.push_used_simd(&used_simds)?;
-
-            for r in used_simds.iter().rev() {
-                let content =
-                    self.state.register_values[self.machine.index_from_simd(*r).0].clone();
-                if content == MachineValue::Undefined {
-                    return Err(CompileError::Codegen(
-                        "emit_call_native: Undefined used_simds content".to_owned(),
-                    ));
-                }
-                self.state.stack_values.push(content);
-            }
         }
         // mark the GPR used for Call as used
         self.machine
-            .reserve_unused_temp_gpr(self.machine.get_grp_for_call());
+            .reserve_unused_temp_gpr(self.machine.get_gpr_for_call());
 
         let calling_convention = self.calling_convention;
 
@@ -826,13 +703,25 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         };
 
         let mut stack_offset: usize = 0;
-        let mut args: Vec<Location<M::GPR, M::SIMD>> = vec![];
-        let mut pushed_args: usize = 0;
-        // Calculate stack offset.
-        for (i, _param) in params.iter().enumerate() {
+        // Allocate space for return values relative to SP (the allocation happens in reverse order, thus start with return slots).
+        let mut return_args = Vec::with_capacity(return_value_sizes.len());
+        for i in 0..return_value_sizes.len() {
+            return_args.push(self.machine.get_return_value_location(
+                i,
+                &mut stack_offset,
+                self.calling_convention,
+            ));
+        }
+
+        // Allocate space for arguments relative to SP.
+        let mut args = Vec::with_capacity(params.len());
+        for (i, param_size) in param_sizes.iter().enumerate() {
             args.push(self.machine.get_param_location(
-                1 + i,
-                params_size[i],
+                match call_type {
+                    NativeCallType::IncludeVMCtxArgument => 1,
+                    NativeCallType::Unreachable => 0,
+                } + i,
+                *param_size,
                 &mut stack_offset,
                 calling_convention,
             ));
@@ -840,64 +729,29 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
         // Align stack to 16 bytes.
         let stack_unaligned =
-            (self.machine.round_stack_adjust(self.get_stack_offset()) + used_stack + stack_offset)
-                % 16;
+            (self.machine.round_stack_adjust(self.stack_offset) + used_stack + stack_offset) % 16;
         if stack_unaligned != 0 {
             stack_offset += 16 - stack_unaligned;
         }
-        self.machine.adjust_stack(stack_offset as u32)?;
+        self.machine.extend_stack(stack_offset as u32)?;
 
         #[allow(clippy::type_complexity)]
         let mut call_movs: Vec<(Location<M::GPR, M::SIMD>, M::GPR)> = vec![];
         // Prepare register & stack parameters.
-        for (i, param) in params.iter().enumerate().rev() {
+        for (i, (param, _)) in params.iter().enumerate().rev() {
             let loc = args[i];
             match loc {
                 Location::GPR(x) => {
                     call_movs.push((*param, x));
                 }
                 Location::Memory(_, _) => {
-                    pushed_args += 1;
-                    match *param {
-                        Location::GPR(x) => {
-                            let content = self.state.register_values
-                                [self.machine.index_from_gpr(x).0]
-                                .clone();
-                            // FIXME: There might be some corner cases (release -> emit_call_native -> acquire?) that cause this assertion to fail.
-                            // Hopefully nothing would be incorrect at runtime.
-
-                            //assert!(content != MachineValue::Undefined);
-                            self.state.stack_values.push(content);
-                        }
-                        Location::SIMD(x) => {
-                            let content = self.state.register_values
-                                [self.machine.index_from_simd(x).0]
-                                .clone();
-                            //assert!(content != MachineValue::Undefined);
-                            self.state.stack_values.push(content);
-                        }
-                        Location::Memory(reg, offset) => {
-                            if reg != self.machine.local_pointer() {
-                                return Err(CompileError::Codegen(
-                                    "emit_call_native loc param: unreachable code".to_owned(),
-                                ));
-                            }
-                            self.state
-                                .stack_values
-                                .push(MachineValue::CopyStackBPRelative(offset));
-                            // TODO: Read value at this offset
-                        }
-                        _ => {
-                            self.state.stack_values.push(MachineValue::Undefined);
-                        }
-                    }
                     self.machine
-                        .move_location_for_native(params_size[i], *param, loc)?;
+                        .move_location_for_native(param_sizes[i], *param, loc)?;
                 }
                 _ => {
                     return Err(CompileError::Codegen(
                         "emit_call_native loc: unreachable code".to_owned(),
-                    ))
+                    ));
                 }
             }
         }
@@ -913,107 +767,66 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
         }
 
-        // Put vmctx as the first parameter.
-        self.machine.move_location(
-            Size::S64,
-            Location::GPR(self.machine.get_vmctx_reg()),
-            self.machine
-                .get_simple_param_location(0, calling_convention),
-        )?; // vmctx
+        if matches!(call_type, NativeCallType::IncludeVMCtxArgument) {
+            // Put vmctx as the first parameter.
+            self.machine.move_location(
+                Size::S64,
+                Location::GPR(self.machine.get_vmctx_reg()),
+                Location::GPR(
+                    self.machine
+                        .get_simple_param_location(0, calling_convention),
+                ),
+            )?; // vmctx
+        }
 
         if stack_padding > 0 {
-            self.machine.adjust_stack(stack_padding as u32)?;
+            self.machine.extend_stack(stack_padding as u32)?;
         }
         // release the GPR used for call
-        self.machine.release_gpr(self.machine.get_grp_for_call());
-        cb(self)?;
+        self.machine.release_gpr(self.machine.get_gpr_for_call());
 
-        // Offset needs to be after the 'call' instruction.
-        // TODO: Now the state information is also inserted for internal calls (e.g. MemoryGrow). Is this expected?
-        {
-            let state_diff_id = self.get_state_diff();
-            let offset = self.machine.assembler_get_offset().0;
-            self.fsm.call_offsets.insert(
-                offset,
-                OffsetInfo {
-                    end_offset: offset + 1,
-                    activate_offset: offset,
-                    diff_id: state_diff_id,
-                },
+        let begin = self.machine.assembler_get_offset().0;
+        cb(self)?;
+        if matches!(call_type, NativeCallType::Unreachable) {
+            let end = self.machine.assembler_get_offset().0;
+            self.machine.mark_address_range_with_trap_code(
+                TrapCode::UnreachableCodeReached,
+                begin,
+                end,
             );
-            self.fsm
-                .wasm_offset_to_target_offset
-                .insert(self.state.wasm_inst_offset, SuspendOffset::Call(offset));
+        }
+
+        // Take the returned values from the fn call.
+        for (i, &return_type) in return_value_sizes.iter().enumerate() {
+            self.machine.move_location_for_native(
+                return_type,
+                return_args[i],
+                return_values[i].0,
+            )?;
         }
 
         // Restore stack.
         if stack_offset + stack_padding > 0 {
-            self.machine.restore_stack(
-                self.machine
-                    .round_stack_adjust(stack_offset + stack_padding) as u32,
-            )?;
-            if (stack_offset % 8) != 0 {
-                return Err(CompileError::Codegen(
-                    "emit_call_native: Bad restoring stack alignement".to_owned(),
-                ));
-            }
-            for _ in 0..pushed_args {
-                self.state
-                    .stack_values
-                    .pop()
-                    .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
-            }
+            self.machine
+                .truncate_stack((stack_offset + stack_padding) as u32)?;
         }
 
         // Restore SIMDs.
         if !used_simds.is_empty() {
             self.machine.pop_used_simd(&used_simds)?;
-            for _ in 0..used_simds.len() {
-                self.state
-                    .stack_values
-                    .pop()
-                    .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
-            }
         }
 
         // Restore GPRs.
         self.machine.pop_used_gpr(&used_gprs)?;
-        for _ in used_gprs.iter().rev() {
-            self.state
-                .stack_values
-                .pop()
-                .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
-        }
 
-        if self
-            .state
-            .stack_values
-            .pop()
-            .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?
-            != MachineValue::ExplicitShadow
-        {
-            return Err(CompileError::Codegen(
-                "emit_call_native: Popped value is not ExplicitShadow".to_owned(),
-            ));
-        }
-        Ok(())
-    }
+        // We are re-using the params for the return values, thus release just the chunk
+        // we're not planning to use!
+        let params_to_release =
+            &stack_params[cmp::min(stack_params.len(), return_value_sizes.len())..];
+        self.release_stack_locations(params_to_release)?;
+
+        self.value_stack.extend(return_values);
 
-    /// Emits a Native ABI call sequence, specialized for labels as the call target.
-    fn _emit_call_native_label<
-        I: Iterator<Item = Location<M::GPR, M::SIMD>>,
-        J: Iterator<Item = WpType>,
-    >(
-        &mut self,
-        label: Label,
-        params: I,
-        params_type: J,
-    ) -> Result<(), CompileError> {
-        self.emit_call_native(
-            |this| this.machine.emit_call_label(label),
-            params,
-            params_type,
-        )?;
         Ok(())
     }
 
@@ -1046,21 +859,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         )
     }
 
-    pub fn get_state_diff(&mut self) -> usize {
-        if !self.track_state {
-            return std::usize::MAX;
-        }
-        let last_frame = self.control_stack.last_mut().unwrap();
-        let mut diff = self.state.diff(&last_frame.state);
-        diff.last = Some(last_frame.state_diff_id);
-        let id = self.fsm.diffs.len();
-        last_frame.state = self.state.clone();
-        last_frame.state_diff_id = id;
-        self.fsm.diffs.push(diff);
-        id
-    }
-
     fn emit_head(&mut self) -> Result<(), CompileError> {
+        self.add_assembly_comment(AssemblyComment::FunctionPrologue);
         self.machine.emit_function_prolog()?;
 
         // Initialize locals.
@@ -1070,32 +870,32 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             self.calling_convention,
         )?;
 
-        // Mark vmctx register. The actual loading of the vmctx value is handled by init_local.
-        self.state.register_values[self.machine.index_from_gpr(self.machine.get_vmctx_reg()).0] =
-            MachineValue::Vmctx;
+        // simulate "red zone" if not supported by the platform
+        self.add_assembly_comment(AssemblyComment::RedZone);
+        self.machine.extend_stack(32)?;
 
-        // TODO: Explicit stack check is not supported for now.
-        let diff = self.state.diff(&self.machine.new_machine_state());
-        let state_diff_id = self.fsm.diffs.len();
-        self.fsm.diffs.push(diff);
+        let return_types: SmallVec<_> = self
+            .signature
+            .results()
+            .iter()
+            .map(type_to_wp_type)
+            .collect();
 
-        // simulate "red zone" if not supported by the platform
-        self.machine.adjust_stack(32)?;
+        // Push return value slots for the function return on the stack.
+        self.value_stack.extend((0..return_types.len()).map(|i| {
+            (
+                self.machine
+                    .get_call_return_value_location(i, self.calling_convention),
+                CanonicalizeType::None,
+            )
+        }));
 
         self.control_stack.push(ControlFrame {
+            state: ControlState::Function,
             label: self.machine.get_label(),
-            loop_like: false,
-            if_else: IfElseState::None,
-            returns: self
-                .signature
-                .results()
-                .iter()
-                .map(|&x| type_to_wp_type(x))
-                .collect(),
-            value_stack_depth: 0,
-            fp_stack_depth: 0,
-            state: self.state.clone(),
-            state_diff_id,
+            value_stack_depth: return_types.len(),
+            param_types: smallvec![],
+            return_types,
         });
 
         // TODO: Full preemption by explicit signal checking
@@ -1103,12 +903,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         // We insert set StackOverflow as the default trap that can happen
         // anywhere in the function prologue.
         self.machine.insert_stackoverflow();
+        self.add_assembly_comment(AssemblyComment::FunctionBody);
 
-        if self.state.wasm_inst_offset != std::usize::MAX {
-            return Err(CompileError::Codegen(
-                "emit_head: wasm_inst_offset not std::usize::MAX".to_owned(),
-            ));
-        }
         Ok(())
     }
 
@@ -1128,11 +924,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         let sig_index = module.functions[func_index];
         let signature = module.signatures[sig_index].clone();
 
-        let mut local_types: Vec<_> = signature
-            .params()
-            .iter()
-            .map(|&x| type_to_wp_type(x))
-            .collect();
+        let mut local_types: Vec<_> = signature.params().iter().map(type_to_wp_type).collect();
         local_types.extend_from_slice(local_types_excluding_arguments);
 
         let mut machine = machine;
@@ -1145,15 +937,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             bad_signature: machine.get_label(),
             unaligned_atomic: machine.get_label(),
         };
-
-        let fsm = FunctionStateMap::new(
-            machine.new_machine_state(),
-            local_func_index.index() as usize,
-            32,
-            (0..local_types.len())
-                .map(|_| WasmAbstractValue::Runtime)
-                .collect(),
-        );
+        let function_name = module
+            .function_names
+            .get(&func_index)
+            .map(|fname| fname.to_string())
+            .unwrap_or_else(|| format!("function_{}", func_index.as_u32()));
 
         let mut fg = FuncGen {
             module,
@@ -1165,18 +953,17 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             locals: vec![], // initialization deferred to emit_head
             local_types,
             value_stack: vec![],
-            fp_stack: vec![],
             control_stack: vec![],
-            stack_offset: MachineStackOffset(0),
+            stack_offset: 0,
             save_area_offset: None,
-            state: machine.new_machine_state(),
-            track_state: true,
             machine,
             unreachable_depth: 0,
-            fsm,
+            local_func_index,
             relocations: vec![],
             special_labels,
             calling_convention,
+            function_name,
+            assembly_comments: HashMap::new(),
         };
         fg.emit_head()?;
         Ok(fg)
@@ -1186,12 +973,87 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         !self.control_stack.is_empty()
     }
 
-    pub fn feed_operator(&mut self, op: Operator) -> Result<(), CompileError> {
-        assert!(self.fp_stack.len() <= self.value_stack.len());
+    /// Moves the top `return_values` items from the value stack into the
+    /// preallocated return slots starting at `value_stack_depth_after`.
+    ///
+    /// Used when completing Block/If/Loop constructs or returning from the
+    /// function. Applies NaN canonicalization when enabled and supported.
+    fn emit_return_values(
+        &mut self,
+        value_stack_depth_after: usize,
+        return_values: usize,
+    ) -> Result<(), CompileError> {
+        for (i, (stack_value, canonicalize)) in self
+            .value_stack
+            .iter()
+            .rev()
+            .take(return_values)
+            .enumerate()
+        {
+            let dst = self.value_stack[value_stack_depth_after - i - 1].0;
+            if let Some(canonicalize_size) = canonicalize.to_size()
+                && self.config.enable_nan_canonicalization
+            {
+                self.machine
+                    .canonicalize_nan(canonicalize_size, *stack_value, dst)?;
+            } else {
+                self.machine
+                    .emit_relaxed_mov(Size::S64, *stack_value, dst)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Similar to `emit_return_values`, except it stores the `return_values` items into the slots
+    /// preallocated for parameters of a loop.
+    fn emit_loop_params_store(
+        &mut self,
+        value_stack_depth_after: usize,
+        param_count: usize,
+    ) -> Result<(), CompileError> {
+        for (i, (stack_value, _)) in self
+            .value_stack
+            .iter()
+            .rev()
+            .take(param_count)
+            .rev()
+            .enumerate()
+        {
+            let dst = self.value_stack[value_stack_depth_after + i].0;
+            self.machine
+                .emit_relaxed_mov(Size::S64, *stack_value, dst)?;
+        }
 
-        self.state.wasm_inst_offset = self.state.wasm_inst_offset.wrapping_add(1);
+        Ok(())
+    }
 
-        //println!("{:?} {}", op, self.value_stack.len());
+    fn return_types_for_block(&self, block_type: WpTypeOrFuncType) -> SmallVec<[WpType; 1]> {
+        match block_type {
+            WpTypeOrFuncType::Empty => smallvec![],
+            WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
+            WpTypeOrFuncType::FuncType(sig_index) => SmallVec::from_iter(
+                self.module.signatures[SignatureIndex::from_u32(sig_index)]
+                    .results()
+                    .iter()
+                    .map(type_to_wp_type),
+            ),
+        }
+    }
+
+    fn param_types_for_block(&self, block_type: WpTypeOrFuncType) -> SmallVec<[WpType; 8]> {
+        match block_type {
+            WpTypeOrFuncType::Empty | WpTypeOrFuncType::Type(_) => smallvec![],
+            WpTypeOrFuncType::FuncType(sig_index) => SmallVec::from_iter(
+                self.module.signatures[SignatureIndex::from_u32(sig_index)]
+                    .params()
+                    .iter()
+                    .map(type_to_wp_type),
+            ),
+        }
+    }
+
+    pub fn feed_operator(&mut self, op: Operator) -> Result<(), CompileError> {
         let was_unreachable;
 
         if self.unreachable_depth > 0 {
@@ -1206,12 +1068,13 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 }
                 Operator::Else => {
                     // We are in a reachable true branch
-                    if self.unreachable_depth == 1 {
-                        if let Some(IfElseState::If(_)) =
-                            self.control_stack.last().map(|x| x.if_else)
-                        {
-                            self.unreachable_depth -= 1;
-                        }
+                    if self.unreachable_depth == 1
+                        && self
+                            .control_stack
+                            .last()
+                            .is_some_and(|frame| matches!(frame.state, ControlState::If { .. }))
+                    {
+                        self.unreachable_depth -= 1;
                     }
                 }
                 _ => {}
@@ -1227,16 +1090,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             Operator::GlobalGet { global_index } => {
                 let global_index = GlobalIndex::from_u32(global_index);
 
-                let ty = type_to_wp_type(self.module.globals[global_index].ty);
-                if ty.is_float() {
-                    self.fp_stack.push(FloatValue::new(self.value_stack.len()));
-                }
-                let loc = self.acquire_locations(
-                    &[(ty, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(loc);
-
+                let ty = type_to_wp_type(&self.module.globals[global_index].ty);
+                let loc = self.acquire_location(&ty)?;
+                self.value_stack.push((loc, CanonicalizeType::None));
+
                 let tmp = self.machine.acquire_temp_gpr().unwrap();
 
                 let src = if let Some(local_global_index) =
@@ -1291,23 +1148,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     )?;
                     Location::Memory(tmp, 0)
                 };
-                let ty = type_to_wp_type(self.module.globals[global_index].ty);
-                let loc = self.pop_value_released()?;
-                if ty.is_float() {
-                    let fp = self.fp_stack.pop1()?;
-                    if self.machine.arch_supports_canonicalize_nan()
-                        && self.config.enable_nan_canonicalization
-                        && fp.canonicalization.is_some()
-                    {
-                        self.machine.canonicalize_nan(
-                            match ty {
-                                WpType::F32 => Size::S32,
-                                WpType::F64 => Size::S64,
-                                _ => codegen_error!("singlepass Operator::GlobalSet unreachable"),
-                            },
-                            loc,
-                            dst,
-                        )?;
+                let (loc, canonicalize) = self.pop_value_released()?;
+                if let Some(canonicalize_size) = canonicalize.to_size() {
+                    if self.config.enable_nan_canonicalization {
+                        self.machine.canonicalize_nan(canonicalize_size, loc, dst)?;
                     } else {
                         self.machine.emit_relaxed_mov(Size::S64, loc, dst)?;
                     }
@@ -1318,34 +1162,21 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
             Operator::LocalGet { local_index } => {
                 let local_index = local_index as usize;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
+                let ret = self.acquire_location(&WpType::I64)?;
                 self.machine
                     .emit_relaxed_mov(Size::S64, self.locals[local_index], ret)?;
-                self.value_stack.push(ret);
-                if self.local_types[local_index].is_float() {
-                    self.fp_stack
-                        .push(FloatValue::new(self.value_stack.len() - 1));
-                }
+                self.value_stack.push((ret, CanonicalizeType::None));
             }
             Operator::LocalSet { local_index } => {
                 let local_index = local_index as usize;
-                let loc = self.pop_value_released()?;
+                let (loc, canonicalize) = self.pop_value_released()?;
 
-                if self.local_types[local_index].is_float() {
-                    let fp = self.fp_stack.pop1()?;
-                    if self.machine.arch_supports_canonicalize_nan()
-                        && self.config.enable_nan_canonicalization
-                        && fp.canonicalization.is_some()
-                    {
+                if self.local_types[local_index].is_float()
+                    && let Some(canonicalize_size) = canonicalize.to_size()
+                {
+                    if self.config.enable_nan_canonicalization {
                         self.machine.canonicalize_nan(
-                            match self.local_types[local_index] {
-                                WpType::F32 => Size::S32,
-                                WpType::F64 => Size::S64,
-                                _ => codegen_error!("singlepass Operator::LocalSet unreachable"),
-                            },
+                            canonicalize_size,
                             loc,
                             self.locals[local_index],
                         )
@@ -1360,20 +1191,14 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
             Operator::LocalTee { local_index } => {
                 let local_index = local_index as usize;
-                let loc = *self.value_stack.last().unwrap();
+                let (loc, canonicalize) = *self.value_stack.last().unwrap();
 
-                if self.local_types[local_index].is_float() {
-                    let fp = self.fp_stack.peek1()?;
-                    if self.machine.arch_supports_canonicalize_nan()
-                        && self.config.enable_nan_canonicalization
-                        && fp.canonicalization.is_some()
-                    {
+                if self.local_types[local_index].is_float()
+                    && let Some(canonicalize_size) = canonicalize.to_size()
+                {
+                    if self.config.enable_nan_canonicalization {
                         self.machine.canonicalize_nan(
-                            match self.local_types[local_index] {
-                                WpType::F32 => Size::S32,
-                                WpType::F64 => Size::S64,
-                                _ => codegen_error!("singlepass Operator::LocalTee unreachable"),
-                            },
+                            canonicalize_size,
                             loc,
                             self.locals[local_index],
                         )
@@ -1387,351 +1212,358 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 }?;
             }
             Operator::I32Const { value } => {
-                self.value_stack.push(Location::Imm32(value as u32));
-                self.state
-                    .wasm_stack
-                    .push(WasmAbstractValue::Const(value as u32 as u64));
+                self.value_stack
+                    .push((Location::Imm32(value as u32), CanonicalizeType::None));
             }
             Operator::I32Add => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_add32(loc_a, loc_b, ret)?;
             }
             Operator::I32Sub => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_sub32(loc_a, loc_b, ret)?;
             }
             Operator::I32Mul => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_mul32(loc_a, loc_b, ret)?;
             }
             Operator::I32DivU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
-                let offset = self.machine.emit_binop_udiv32(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
+                self.machine.emit_binop_udiv32(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I32DivS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
-                let offset = self.machine.emit_binop_sdiv32(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
+                self.machine.emit_binop_sdiv32(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
                     self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I32RemU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
-                let offset = self.machine.emit_binop_urem32(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
+                self.machine.emit_binop_urem32(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I32RemS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
-                let offset = self.machine.emit_binop_srem32(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
+                self.machine.emit_binop_srem32(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I32And => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_and32(loc_a, loc_b, ret)?;
             }
             Operator::I32Or => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_or32(loc_a, loc_b, ret)?;
             }
             Operator::I32Xor => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.emit_binop_xor32(loc_a, loc_b, ret)?;
             }
             Operator::I32Eq => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_eq(loc_a, loc_b, ret)?;
             }
             Operator::I32Ne => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_ne(loc_a, loc_b, ret)?;
             }
             Operator::I32Eqz => {
-                let loc_a = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
+                let loc_a = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
                 self.machine.i32_cmp_eq(loc_a, Location::Imm32(0), ret)?;
-                self.value_stack.push(ret);
+                self.value_stack.push((ret, CanonicalizeType::None));
             }
             Operator::I32Clz => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i32_clz(loc, ret)?;
             }
             Operator::I32Ctz => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i32_ctz(loc, ret)?;
             }
             Operator::I32Popcnt => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i32_popcnt(loc, ret)?;
             }
             Operator::I32Shl => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_shl(loc_a, loc_b, ret)?;
             }
             Operator::I32ShrU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_shr(loc_a, loc_b, ret)?;
             }
             Operator::I32ShrS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_sar(loc_a, loc_b, ret)?;
             }
             Operator::I32Rotl => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_rol(loc_a, loc_b, ret)?;
             }
             Operator::I32Rotr => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_ror(loc_a, loc_b, ret)?;
             }
             Operator::I32LtU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_lt_u(loc_a, loc_b, ret)?;
             }
             Operator::I32LeU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_le_u(loc_a, loc_b, ret)?;
             }
             Operator::I32GtU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_gt_u(loc_a, loc_b, ret)?;
             }
             Operator::I32GeU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_ge_u(loc_a, loc_b, ret)?;
             }
             Operator::I32LtS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_lt_s(loc_a, loc_b, ret)?;
             }
             Operator::I32LeS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_le_s(loc_a, loc_b, ret)?;
             }
             Operator::I32GtS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_gt_s(loc_a, loc_b, ret)?;
             }
             Operator::I32GeS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.i32_cmp_ge_s(loc_a, loc_b, ret)?;
             }
             Operator::I64Const { value } => {
                 let value = value as u64;
-                self.value_stack.push(Location::Imm64(value));
-                self.state.wasm_stack.push(WasmAbstractValue::Const(value));
+                self.value_stack
+                    .push((Location::Imm64(value), CanonicalizeType::None));
             }
             Operator::I64Add => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_add64(loc_a, loc_b, ret)?;
             }
             Operator::I64Sub => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_sub64(loc_a, loc_b, ret)?;
             }
             Operator::I64Mul => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_mul64(loc_a, loc_b, ret)?;
             }
             Operator::I64DivU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
-                let offset = self.machine.emit_binop_udiv64(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
+                self.machine.emit_binop_udiv64(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I64DivS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
-                let offset = self.machine.emit_binop_sdiv64(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
+                self.machine.emit_binop_sdiv64(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
                     self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I64RemU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
-                let offset = self.machine.emit_binop_urem64(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
+                self.machine.emit_binop_urem64(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I64RemS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
-                let offset = self.machine.emit_binop_srem64(
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
+                self.machine.emit_binop_srem64(
                     loc_a,
                     loc_b,
                     ret,
                     self.special_labels.integer_division_by_zero,
-                    self.special_labels.integer_overflow,
                 )?;
-                self.mark_offset_trappable(offset);
             }
             Operator::I64And => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_and64(loc_a, loc_b, ret)?;
             }
             Operator::I64Or => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_or64(loc_a, loc_b, ret)?;
             }
             Operator::I64Xor => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.emit_binop_xor64(loc_a, loc_b, ret)?;
             }
             Operator::I64Eq => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_eq(loc_a, loc_b, ret)?;
             }
             Operator::I64Ne => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_ne(loc_a, loc_b, ret)?;
             }
             Operator::I64Eqz => {
-                let loc_a = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
+                let loc_a = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
                 self.machine.i64_cmp_eq(loc_a, Location::Imm64(0), ret)?;
-                self.value_stack.push(ret);
+                self.value_stack.push((ret, CanonicalizeType::None));
             }
             Operator::I64Clz => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i64_clz(loc, ret)?;
             }
             Operator::I64Ctz => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i64_ctz(loc, ret)?;
             }
             Operator::I64Popcnt => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.i64_popcnt(loc, ret)?;
             }
             Operator::I64Shl => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_shl(loc_a, loc_b, ret)?;
             }
             Operator::I64ShrU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_shr(loc_a, loc_b, ret)?;
             }
             Operator::I64ShrS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_sar(loc_a, loc_b, ret)?;
             }
             Operator::I64Rotl => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_rol(loc_a, loc_b, ret)?;
             }
             Operator::I64Rotr => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_ror(loc_a, loc_b, ret)?;
             }
             Operator::I64LtU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_lt_u(loc_a, loc_b, ret)?;
             }
             Operator::I64LeU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_le_u(loc_a, loc_b, ret)?;
             }
             Operator::I64GtU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_gt_u(loc_a, loc_b, ret)?;
             }
             Operator::I64GeU => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_ge_u(loc_a, loc_b, ret)?;
             }
             Operator::I64LtS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_lt_s(loc_a, loc_b, ret)?;
             }
             Operator::I64LeS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_le_s(loc_a, loc_b, ret)?;
             }
             Operator::I64GtS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_gt_s(loc_a, loc_b, ret)?;
             }
             Operator::I64GeS => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I64, CanonicalizeType::None)?;
                 self.machine.i64_cmp_ge_s(loc_a, loc_b, ret)?;
             }
             Operator::I64ExtendI32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
 
                 // A 32-bit memory write does not automatically clear the upper 32 bits of a 64-bit word.
@@ -1745,255 +1577,178 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 }
             }
             Operator::I64ExtendI32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine
                     .emit_relaxed_sign_extension(Size::S32, loc, Size::S64, ret)?;
             }
             Operator::I32Extend8S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine
                     .emit_relaxed_sign_extension(Size::S8, loc, Size::S32, ret)?;
             }
             Operator::I32Extend16S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine
                     .emit_relaxed_sign_extension(Size::S16, loc, Size::S32, ret)?;
             }
             Operator::I64Extend8S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine
                     .emit_relaxed_sign_extension(Size::S8, loc, Size::S64, ret)?;
             }
             Operator::I64Extend16S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine
                     .emit_relaxed_sign_extension(Size::S16, loc, Size::S64, ret)?;
             }
             Operator::I64Extend32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine
                     .emit_relaxed_sign_extension(Size::S32, loc, Size::S64, ret)?;
             }
             Operator::I32WrapI64 => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
             }
 
             Operator::F32Const { value } => {
-                self.value_stack.push(Location::Imm32(value.bits()));
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
-                self.state
-                    .wasm_stack
-                    .push(WasmAbstractValue::Const(value.bits() as u64));
+                self.value_stack
+                    .push((Location::Imm32(value.bits()), CanonicalizeType::None));
             }
             Operator::F32Add => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F32)?;
                 self.machine.f32_add(loc_a, loc_b, ret)?;
             }
             Operator::F32Sub => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F32)?;
                 self.machine.f32_sub(loc_a, loc_b, ret)?;
             }
             Operator::F32Mul => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F32)?;
                 self.machine.f32_mul(loc_a, loc_b, ret)?;
             }
             Operator::F32Div => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F32)?;
                 self.machine.f32_div(loc_a, loc_b, ret)?;
             }
             Operator::F32Max => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::None)?;
                 self.machine.f32_max(loc_a, loc_b, ret)?;
             }
             Operator::F32Min => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::None)?;
                 self.machine.f32_min(loc_a, loc_b, ret)?;
             }
             Operator::F32Eq => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_eq(loc_a, loc_b, ret)?;
             }
             Operator::F32Ne => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_ne(loc_a, loc_b, ret)?;
             }
             Operator::F32Lt => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_lt(loc_a, loc_b, ret)?;
             }
             Operator::F32Le => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_le(loc_a, loc_b, ret)?;
             }
             Operator::F32Gt => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_gt(loc_a, loc_b, ret)?;
             }
             Operator::F32Ge => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f32_cmp_ge(loc_a, loc_b, ret)?;
             }
             Operator::F32Nearest => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F32));
                 self.machine.f32_nearest(loc, ret)?;
             }
             Operator::F32Floor => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F32));
                 self.machine.f32_floor(loc, ret)?;
             }
             Operator::F32Ceil => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F32));
                 self.machine.f32_ceil(loc, ret)?;
             }
             Operator::F32Trunc => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F32));
                 self.machine.f32_trunc(loc, ret)?;
             }
             Operator::F32Sqrt => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F32));
                 self.machine.f32_sqrt(loc, ret)?;
             }
 
             Operator::F32Copysign => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F32)?;
-
-                let (fp_src1, fp_src2) = self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let loc_b = self.pop_value_released()?;
+                let loc_a = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 let tmp1 = self.machine.acquire_temp_gpr().unwrap();
                 let tmp2 = self.machine.acquire_temp_gpr().unwrap();
 
-                if self.machine.arch_supports_canonicalize_nan()
-                    && self.config.enable_nan_canonicalization
-                {
-                    for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() {
-                        match fp.canonicalization {
-                            Some(_) => {
-                                self.machine
-                                    .canonicalize_nan(Size::S32, *loc, Location::GPR(*tmp))
-                            }
-                            None => {
-                                self.machine
-                                    .move_location(Size::S32, *loc, Location::GPR(*tmp))
-                            }
-                        }?;
+                if self.config.enable_nan_canonicalization {
+                    for ((loc, fp), tmp) in [(loc_a, tmp1), (loc_b, tmp2)] {
+                        if fp.to_size().is_some() {
+                            self.machine
+                                .canonicalize_nan(Size::S32, loc, Location::GPR(tmp))?
+                        } else {
+                            self.machine
+                                .move_location(Size::S32, loc, Location::GPR(tmp))?
+                        }
                     }
                 } else {
                     self.machine
-                        .move_location(Size::S32, loc_a, Location::GPR(tmp1))?;
+                        .move_location(Size::S32, loc_a.0, Location::GPR(tmp1))?;
                     self.machine
-                        .move_location(Size::S32, loc_b, Location::GPR(tmp2))?;
+                        .move_location(Size::S32, loc_b.0, Location::GPR(tmp2))?;
                 }
                 self.machine.emit_i32_copysign(tmp1, tmp2)?;
                 self.machine
@@ -2005,12 +1760,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             Operator::F32Abs => {
                 // Preserve canonicalization state.
 
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.f32_abs(loc, ret)?;
             }
@@ -2018,191 +1770,132 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             Operator::F32Neg => {
                 // Preserve canonicalization state.
 
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.f32_neg(loc, ret)?;
             }
 
             Operator::F64Const { value } => {
-                self.value_stack.push(Location::Imm64(value.bits()));
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
-                self.state
-                    .wasm_stack
-                    .push(WasmAbstractValue::Const(value.bits()));
+                self.value_stack
+                    .push((Location::Imm64(value.bits()), CanonicalizeType::None));
             }
             Operator::F64Add => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F64)?;
                 self.machine.f64_add(loc_a, loc_b, ret)?;
             }
             Operator::F64Sub => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F64)?;
                 self.machine.f64_sub(loc_a, loc_b, ret)?;
             }
             Operator::F64Mul => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F64)?;
                 self.machine.f64_mul(loc_a, loc_b, ret)?;
             }
             Operator::F64Div => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::F64)?;
                 self.machine.f64_div(loc_a, loc_b, ret)?;
             }
             Operator::F64Max => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::None)?;
                 self.machine.f64_max(loc_a, loc_b, ret)?;
             }
             Operator::F64Min => {
-                self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 2));
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::F64, CanonicalizeType::None)?;
                 self.machine.f64_min(loc_a, loc_b, ret)?;
             }
             Operator::F64Eq => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_eq(loc_a, loc_b, ret)?;
             }
             Operator::F64Ne => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_ne(loc_a, loc_b, ret)?;
             }
             Operator::F64Lt => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_lt(loc_a, loc_b, ret)?;
             }
             Operator::F64Le => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_le(loc_a, loc_b, ret)?;
             }
             Operator::F64Gt => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_gt(loc_a, loc_b, ret)?;
             }
             Operator::F64Ge => {
-                self.fp_stack.pop2()?;
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let I2O1 { loc_a, loc_b, ret } =
+                    self.i2o1_prepare(WpType::I32, CanonicalizeType::None)?;
                 self.machine.f64_cmp_ge(loc_a, loc_b, ret)?;
             }
             Operator::F64Nearest => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F64));
                 self.machine.f64_nearest(loc, ret)?;
             }
             Operator::F64Floor => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F64));
                 self.machine.f64_floor(loc, ret)?;
             }
             Operator::F64Ceil => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F64));
                 self.machine.f64_ceil(loc, ret)?;
             }
             Operator::F64Trunc => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F64));
                 self.machine.f64_trunc(loc, ret)?;
             }
             Operator::F64Sqrt => {
-                self.fp_stack.pop1()?;
-                self.fp_stack
-                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::F64));
                 self.machine.f64_sqrt(loc, ret)?;
             }
 
             Operator::F64Copysign => {
-                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
-
-                let (fp_src1, fp_src2) = self.fp_stack.pop2()?;
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let loc_b = self.pop_value_released()?;
+                let loc_a = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 let tmp1 = self.machine.acquire_temp_gpr().unwrap();
                 let tmp2 = self.machine.acquire_temp_gpr().unwrap();
 
-                if self.machine.arch_supports_canonicalize_nan()
-                    && self.config.enable_nan_canonicalization
-                {
-                    for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() {
-                        match fp.canonicalization {
-                            Some(_) => {
-                                self.machine
-                                    .canonicalize_nan(Size::S64, *loc, Location::GPR(*tmp))
-                            }
-                            None => {
-                                self.machine
-                                    .move_location(Size::S64, *loc, Location::GPR(*tmp))
-                            }
-                        }?;
+                if self.config.enable_nan_canonicalization {
+                    for ((loc, fp), tmp) in [(loc_a, tmp1), (loc_b, tmp2)] {
+                        if fp.to_size().is_some() {
+                            self.machine
+                                .canonicalize_nan(Size::S64, loc, Location::GPR(tmp))?
+                        } else {
+                            self.machine
+                                .move_location(Size::S64, loc, Location::GPR(tmp))?
+                        }
                     }
                 } else {
                     self.machine
-                        .move_location(Size::S64, loc_a, Location::GPR(tmp1))?;
+                        .move_location(Size::S64, loc_a.0, Location::GPR(tmp1))?;
                     self.machine
-                        .move_location(Size::S64, loc_b, Location::GPR(tmp2))?;
+                        .move_location(Size::S64, loc_b.0, Location::GPR(tmp2))?;
                 }
                 self.machine.emit_i64_copysign(tmp1, tmp2)?;
                 self.machine
@@ -2213,66 +1906,41 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
 
             Operator::F64Abs => {
-                // Preserve canonicalization state.
-
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, canonicalize));
 
                 self.machine.f64_abs(loc, ret)?;
             }
 
             Operator::F64Neg => {
-                // Preserve canonicalization state.
-
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, canonicalize));
 
                 self.machine.f64_neg(loc, ret)?;
             }
 
             Operator::F64PromoteF32 => {
-                let fp = self.fp_stack.pop1()?;
-                self.fp_stack.push(fp.promote(self.value_stack.len() - 1)?);
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, canonicalize.promote()?));
                 self.machine.convert_f64_f32(loc, ret)?;
             }
             Operator::F32DemoteF64 => {
-                let fp = self.fp_stack.pop1()?;
-                self.fp_stack.push(fp.demote(self.value_stack.len() - 1)?);
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, canonicalize.demote()?));
                 self.machine.convert_f32_f64(loc, ret)?;
             }
 
             Operator::I32ReinterpretF32 => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                let fp = self.fp_stack.pop1()?;
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
-                if !self.machine.arch_supports_canonicalize_nan()
-                    || !self.config.enable_nan_canonicalization
-                    || fp.canonicalization.is_none()
+                if !self.config.enable_nan_canonicalization
+                    || matches!(canonicalize, CanonicalizeType::None)
                 {
                     if loc != ret {
                         self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
@@ -2282,14 +1950,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 }
             }
             Operator::F32ReinterpretI32 => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 if loc != ret {
                     self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
@@ -2297,17 +1960,12 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
 
             Operator::I64ReinterpretF64 => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                let fp = self.fp_stack.pop1()?;
+                let (loc, canonicalize) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
-                if !self.machine.arch_supports_canonicalize_nan()
-                    || !self.config.enable_nan_canonicalization
-                    || fp.canonicalization.is_none()
+                if !self.config.enable_nan_canonicalization
+                    || matches!(canonicalize, CanonicalizeType::None)
                 {
                     if loc != ret {
                         self.machine.emit_relaxed_mov(Size::S64, loc, ret)?;
@@ -2317,14 +1975,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 }
             }
             Operator::F64ReinterpretI64 => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 if loc != ret {
                     self.machine.emit_relaxed_mov(Size::S64, loc, ret)?;
@@ -2332,289 +1985,185 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
 
             Operator::I32TruncF32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f32(loc, ret, false, false)?;
             }
 
             Operator::I32TruncSatF32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f32(loc, ret, false, true)?;
             }
 
             Operator::I32TruncF32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f32(loc, ret, true, false)?;
             }
             Operator::I32TruncSatF32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f32(loc, ret, true, true)?;
             }
 
             Operator::I64TruncF32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f32(loc, ret, true, false)?;
             }
 
             Operator::I64TruncSatF32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f32(loc, ret, true, true)?;
             }
 
             Operator::I64TruncF32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f32(loc, ret, false, false)?;
             }
             Operator::I64TruncSatF32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f32(loc, ret, false, true)?;
             }
 
             Operator::I32TruncF64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f64(loc, ret, false, false)?;
             }
 
             Operator::I32TruncSatF64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f64(loc, ret, false, true)?;
             }
 
             Operator::I32TruncF64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f64(loc, ret, true, false)?;
             }
 
             Operator::I32TruncSatF64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i32_f64(loc, ret, true, true)?;
             }
 
             Operator::I64TruncF64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f64(loc, ret, true, false)?;
             }
 
             Operator::I64TruncSatF64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f64(loc, ret, true, true)?;
             }
 
             Operator::I64TruncF64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f64(loc, ret, false, false)?;
             }
 
             Operator::I64TruncSatF64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack.pop1()?;
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_i64_f64(loc, ret, false, true)?;
             }
 
             Operator::F32ConvertI32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f32_i32(loc, true, ret)?;
             }
             Operator::F32ConvertI32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f32_i32(loc, false, ret)?;
             }
             Operator::F32ConvertI64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f32_i64(loc, true, ret)?;
             }
             Operator::F32ConvertI64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f32_i64(loc, false, ret)?;
             }
 
             Operator::F64ConvertI32S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f64_i32(loc, true, ret)?;
             }
             Operator::F64ConvertI32U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f64_i32(loc, false, ret)?;
             }
             Operator::F64ConvertI64S => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f64_i64(loc, true, ret)?;
             }
             Operator::F64ConvertI64U => {
-                let loc = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN.
+                let loc = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 self.machine.convert_f64_i64(loc, false, ret)?;
             }
@@ -2629,36 +2178,24 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     .unwrap();
                 let sig = self.module.signatures.get(sig_index).unwrap();
                 let param_types: SmallVec<[WpType; 8]> =
-                    sig.params().iter().cloned().map(type_to_wp_type).collect();
+                    sig.params().iter().map(type_to_wp_type).collect();
                 let return_types: SmallVec<[WpType; 1]> =
-                    sig.results().iter().cloned().map(type_to_wp_type).collect();
+                    sig.results().iter().map(type_to_wp_type).collect();
 
                 let params: SmallVec<[_; 8]> = self
                     .value_stack
                     .drain(self.value_stack.len() - param_types.len()..)
                     .collect();
-                self.release_locations_only_regs(&params)?;
-
-                self.release_locations_only_osr_state(params.len())?;
 
                 // Pop arguments off the FP stack and canonicalize them if needed.
                 //
                 // Canonicalization state will be lost across function calls, so early canonicalization
                 // is necessary here.
-                while let Some(fp) = self.fp_stack.last() {
-                    if fp.depth >= self.value_stack.len() {
-                        let index = fp.depth - self.value_stack.len();
-                        if self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
-                        {
-                            let size = fp.canonicalization.unwrap().to_size();
-                            self.machine
-                                .canonicalize_nan(size, params[index], params[index])?;
+                if self.config.enable_nan_canonicalization {
+                    for (loc, canonicalize) in params.iter() {
+                        if let Some(size) = canonicalize.to_size() {
+                            self.machine.canonicalize_nan(size, *loc, *loc)?;
                         }
-                        self.fp_stack.pop().unwrap();
-                    } else {
-                        break;
                     }
                 }
 
@@ -2686,40 +2223,13 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     },
                     params.iter().copied(),
                     param_types.iter().copied(),
+                    return_types.iter().copied(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&params)?;
-
-                if !return_types.is_empty() {
-                    let ret = self.acquire_locations(
-                        &[(
-                            return_types[0],
-                            MachineValue::WasmStack(self.value_stack.len()),
-                        )],
-                        false,
-                    )?[0];
-                    self.value_stack.push(ret);
-                    if return_types[0].is_float() {
-                        self.machine.move_location(
-                            Size::S64,
-                            Location::SIMD(self.machine.get_simd_for_ret()),
-                            ret,
-                        )?;
-                        self.fp_stack
-                            .push(FloatValue::new(self.value_stack.len() - 1));
-                    } else {
-                        self.machine.move_location(
-                            Size::S64,
-                            Location::GPR(self.machine.get_gpr_for_ret()),
-                            ret,
-                        )?;
-                    }
-                }
             }
             Operator::CallIndirect {
                 type_index,
                 table_index,
-                table_byte: _,
             } => {
                 // TODO: removed restriction on always being table idx 0;
                 // does any code depend on this?
@@ -2727,36 +2237,26 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 let index = SignatureIndex::new(type_index as usize);
                 let sig = self.module.signatures.get(index).unwrap();
                 let param_types: SmallVec<[WpType; 8]> =
-                    sig.params().iter().cloned().map(type_to_wp_type).collect();
+                    sig.params().iter().map(type_to_wp_type).collect();
                 let return_types: SmallVec<[WpType; 1]> =
-                    sig.results().iter().cloned().map(type_to_wp_type).collect();
+                    sig.results().iter().map(type_to_wp_type).collect();
 
-                let func_index = self.pop_value_released()?;
+                let func_index = self.pop_value_released()?.0;
 
                 let params: SmallVec<[_; 8]> = self
                     .value_stack
                     .drain(self.value_stack.len() - param_types.len()..)
                     .collect();
-                self.release_locations_only_regs(&params)?;
 
                 // Pop arguments off the FP stack and canonicalize them if needed.
                 //
                 // Canonicalization state will be lost across function calls, so early canonicalization
                 // is necessary here.
-                while let Some(fp) = self.fp_stack.last() {
-                    if fp.depth >= self.value_stack.len() {
-                        let index = fp.depth - self.value_stack.len();
-                        if self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
-                        {
-                            let size = fp.canonicalization.unwrap().to_size();
-                            self.machine
-                                .canonicalize_nan(size, params[index], params[index])?;
+                if self.config.enable_nan_canonicalization {
+                    for (loc, canonicalize) in params.iter() {
+                        if let Some(size) = canonicalize.to_size() {
+                            self.machine.canonicalize_nan(size, *loc, *loc)?;
                         }
-                        self.fp_stack.pop().unwrap();
-                    } else {
-                        break;
                     }
                 }
 
@@ -2807,10 +2307,13 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     )?;
                 }
 
-                self.machine
-                    .location_cmp(Size::S32, func_index, Location::GPR(table_count))?;
-                self.machine
-                    .jmp_on_belowequal(self.special_labels.table_access_oob)?;
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::BelowEqual,
+                    Size::S32,
+                    Location::GPR(table_count),
+                    func_index,
+                    self.special_labels.table_access_oob,
+                )?;
                 self.machine
                     .move_location(Size::S32, func_index, Location::GPR(table_count))?;
                 self.machine.emit_imul_imm32(
@@ -2832,15 +2335,15 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     Location::GPR(table_count),
                 )?;
                 // Trap if the FuncRef is null
-                self.machine.location_cmp(
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::Equal,
                     Size::S64,
-                    Location::Imm32(0),
                     Location::GPR(table_count),
+                    Location::Imm32(0),
+                    self.special_labels.indirect_call_null,
                 )?;
-                self.machine
-                    .jmp_on_equal(self.special_labels.indirect_call_null)?;
                 self.machine.move_location(
-                    Size::S64,
+                    Size::S32,
                     Location::Memory(
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_vmshared_signature_id(index) as i32,
@@ -2849,22 +2352,21 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
 
                 // Trap if signature mismatches.
-                self.machine.location_cmp(
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::NotEqual,
                     Size::S32,
                     Location::GPR(sigidx),
                     Location::Memory(
                         table_count,
                         (self.vmoffsets.vmcaller_checked_anyfunc_type_index() as usize) as i32,
                     ),
+                    self.special_labels.bad_signature,
                 )?;
-                self.machine
-                    .jmp_on_different(self.special_labels.bad_signature)?;
-
                 self.machine.release_gpr(sigidx);
                 self.machine.release_gpr(table_count);
                 self.machine.release_gpr(table_base);
 
-                let gpr_for_call = self.machine.get_grp_for_call();
+                let gpr_for_call = self.machine.get_gpr_for_call();
                 if table_count != gpr_for_call {
                     self.machine.move_location(
                         Size::S64,
@@ -2873,8 +2375,6 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     )?;
                 }
 
-                self.release_locations_only_osr_state(params.len())?;
-
                 let vmcaller_checked_anyfunc_func_ptr =
                     self.vmoffsets.vmcaller_checked_anyfunc_func_ptr() as usize;
                 let vmcaller_checked_anyfunc_vmctx =
@@ -2883,247 +2383,236 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
                 self.emit_call_native(
                     |this| {
-                        if this.machine.arch_requires_indirect_call_trampoline() {
-                            this.machine
-                                .arch_emit_indirect_call_with_trampoline(Location::Memory(
-                                    gpr_for_call,
-                                    vmcaller_checked_anyfunc_func_ptr as i32,
-                                ))
-                        } else {
-                            let offset = this
-                                .machine
-                                .mark_instruction_with_trap_code(TrapCode::StackOverflow);
-
-                            // We set the context pointer
-                            this.machine.move_location(
-                                Size::S64,
-                                Location::Memory(
-                                    gpr_for_call,
-                                    vmcaller_checked_anyfunc_vmctx as i32,
-                                ),
+                        let offset = this
+                            .machine
+                            .mark_instruction_with_trap_code(TrapCode::StackOverflow);
+
+                        // We set the context pointer
+                        this.machine.move_location(
+                            Size::S64,
+                            Location::Memory(gpr_for_call, vmcaller_checked_anyfunc_vmctx as i32),
+                            Location::GPR(
                                 this.machine
                                     .get_simple_param_location(0, calling_convention),
-                            )?;
+                            ),
+                        )?;
 
-                            this.machine.emit_call_location(Location::Memory(
-                                gpr_for_call,
-                                vmcaller_checked_anyfunc_func_ptr as i32,
-                            ))?;
-                            this.machine.mark_instruction_address_end(offset);
-                            Ok(())
-                        }
+                        this.machine.emit_call_location(Location::Memory(
+                            gpr_for_call,
+                            vmcaller_checked_anyfunc_func_ptr as i32,
+                        ))?;
+                        this.machine.mark_instruction_address_end(offset);
+                        Ok(())
                     },
                     params.iter().copied(),
                     param_types.iter().copied(),
+                    return_types.iter().copied(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&params)?;
-
-                if !return_types.is_empty() {
-                    let ret = self.acquire_locations(
-                        &[(
-                            return_types[0],
-                            MachineValue::WasmStack(self.value_stack.len()),
-                        )],
-                        false,
-                    )?[0];
-                    self.value_stack.push(ret);
-                    if return_types[0].is_float() {
-                        self.machine.move_location(
-                            Size::S64,
-                            Location::SIMD(self.machine.get_simd_for_ret()),
-                            ret,
-                        )?;
-                        self.fp_stack
-                            .push(FloatValue::new(self.value_stack.len() - 1));
-                    } else {
-                        self.machine.move_location(
-                            Size::S64,
-                            Location::GPR(self.machine.get_gpr_for_ret()),
-                            ret,
-                        )?;
-                    }
-                }
             }
             Operator::If { blockty } => {
                 let label_end = self.machine.get_label();
                 let label_else = self.machine.get_label();
 
-                let cond = self.pop_value_released()?;
+                let return_types = self.return_types_for_block(blockty);
+                let param_types = self.param_types_for_block(blockty);
+                self.allocate_return_slots_and_swap(param_types.len() + 1, return_types.len())?;
+
+                let cond = self.pop_value_released()?.0;
+
+                /* We might hit a situation where an Operator::If is missing an Operator::Else. In such a situation,
+                the result value just fallthrough from the If block inputs! However, we don't know the information upfront. */
+                if param_types.len() == return_types.len() {
+                    for (input, return_value) in self
+                        .value_stack
+                        .iter()
+                        .rev()
+                        .take(param_types.len())
+                        .zip(self.value_stack.iter().rev().skip(param_types.len()))
+                    {
+                        self.machine
+                            .emit_relaxed_mov(Size::S64, input.0, return_value.0)?;
+                    }
+                }
 
                 let frame = ControlFrame {
-                    label: label_end,
-                    loop_like: false,
-                    if_else: IfElseState::If(label_else),
-                    returns: match blockty {
-                        WpTypeOrFuncType::Empty => smallvec![],
-                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
-                        _ => {
-                            return Err(CompileError::Codegen(
-                                "If: multi-value returns not yet implemented".to_owned(),
-                            ))
-                        }
+                    state: ControlState::If {
+                        label_else,
+                        inputs: SmallVec::from_iter(
+                            self.value_stack
+                                .iter()
+                                .rev()
+                                .take(param_types.len())
+                                .rev()
+                                .copied(),
+                        ),
                     },
+                    label: label_end,
+                    param_types,
+                    return_types,
                     value_stack_depth: self.value_stack.len(),
-                    fp_stack_depth: self.fp_stack.len(),
-                    state: self.state.clone(),
-                    state_diff_id: self.get_state_diff(),
                 };
                 self.control_stack.push(frame);
-                self.machine
-                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
-                self.machine.jmp_on_equal(label_else)?;
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::Equal,
+                    Size::S32,
+                    cond,
+                    Location::Imm32(0),
+                    label_else,
+                )?;
             }
             Operator::Else => {
-                let frame = self.control_stack.last_mut().unwrap();
-
-                if !was_unreachable && !frame.returns.is_empty() {
-                    let first_return = frame.returns[0];
-                    let loc = *self.value_stack.last().unwrap();
-                    let canonicalize = if first_return.is_float() {
-                        let fp = self.fp_stack.peek1()?;
-                        self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
-                    } else {
-                        false
-                    };
-                    self.machine
-                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                let frame = self.control_stack.last().unwrap();
+
+                if !was_unreachable && !frame.return_types.is_empty() {
+                    self.emit_return_values(
+                        frame.value_stack_depth_after(),
+                        frame.return_types.len(),
+                    )?;
                 }
 
                 let frame = &self.control_stack.last_mut().unwrap();
-                let stack_depth = frame.value_stack_depth;
-                let fp_depth = frame.fp_stack_depth;
-                self.release_locations_value(stack_depth)?;
-                self.value_stack.truncate(stack_depth);
-                self.fp_stack.truncate(fp_depth);
+                let locs = self
+                    .value_stack
+                    .drain(frame.value_stack_depth_after()..)
+                    .collect_vec();
+                self.release_locations(&locs)?;
                 let frame = &mut self.control_stack.last_mut().unwrap();
 
-                match frame.if_else {
-                    IfElseState::If(label) => {
-                        self.machine.jmp_unconditionnal(frame.label)?;
-                        self.machine.emit_label(label)?;
-                        frame.if_else = IfElseState::Else;
-                    }
-                    _ => {
-                        return Err(CompileError::Codegen(
-                            "Else: frame.if_else unreachable code".to_owned(),
-                        ))
+                // The Else block must be provided the very same inputs as the previous If block had,
+                // and so we need to copy the already consumed stack values.
+                let ControlState::If {
+                    label_else,
+                    ref inputs,
+                } = frame.state
+                else {
+                    panic!("Operator::Else must be connected to Operator::If statement");
+                };
+                for (input, _) in inputs {
+                    match input {
+                        Location::GPR(x) => {
+                            self.machine.reserve_gpr(*x);
+                        }
+                        Location::SIMD(x) => {
+                            self.machine.reserve_simd(*x);
+                        }
+                        Location::Memory(reg, _) => {
+                            debug_assert_eq!(reg, &self.machine.local_pointer());
+                            self.stack_offset += 8;
+                        }
+                        _ => {}
                     }
                 }
+                self.value_stack.extend(inputs);
+
+                self.machine.jmp_unconditional(frame.label)?;
+                self.machine.emit_label(label_else)?;
+                frame.state = ControlState::Else;
             }
             // `TypedSelect` must be used for extern refs so ref counting should
             // be done with TypedSelect. But otherwise they're the same.
             Operator::TypedSelect { .. } | Operator::Select => {
-                let cond = self.pop_value_released()?;
-                let v_b = self.pop_value_released()?;
-                let v_a = self.pop_value_released()?;
-                let cncl: Option<(Option<CanonicalizeType>, Option<CanonicalizeType>)> =
-                    if self.fp_stack.len() >= 2
-                        && self.fp_stack[self.fp_stack.len() - 2].depth == self.value_stack.len()
-                        && self.fp_stack[self.fp_stack.len() - 1].depth
-                            == self.value_stack.len() + 1
-                    {
-                        let (left, right) = self.fp_stack.pop2()?;
-                        self.fp_stack.push(FloatValue::new(self.value_stack.len()));
-                        Some((left.canonicalization, right.canonicalization))
-                    } else {
-                        None
-                    };
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let cond = self.pop_value_released()?.0;
+                let (v_b, canonicalize_b) = self.pop_value_released()?;
+                let (v_a, canonicalize_a) = self.pop_value_released()?;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
 
                 let end_label = self.machine.get_label();
                 let zero_label = self.machine.get_label();
 
-                self.machine
-                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
-                self.machine.jmp_on_equal(zero_label)?;
-                match cncl {
-                    Some((Some(fp), _))
-                        if self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization =>
-                    {
-                        self.machine.canonicalize_nan(fp.to_size(), v_a, ret)?;
-                    }
-                    _ => {
-                        if v_a != ret {
-                            self.machine.emit_relaxed_mov(Size::S64, v_a, ret)?;
-                        }
-                    }
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::Equal,
+                    Size::S32,
+                    cond,
+                    Location::Imm32(0),
+                    zero_label,
+                )?;
+                if self.config.enable_nan_canonicalization
+                    && let Some(size) = canonicalize_a.to_size()
+                {
+                    self.machine.canonicalize_nan(size, v_a, ret)?;
+                } else if v_a != ret {
+                    self.machine.emit_relaxed_mov(Size::S64, v_a, ret)?;
                 }
-                self.machine.jmp_unconditionnal(end_label)?;
+                self.machine.jmp_unconditional(end_label)?;
                 self.machine.emit_label(zero_label)?;
-                match cncl {
-                    Some((_, Some(fp)))
-                        if self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization =>
-                    {
-                        self.machine.canonicalize_nan(fp.to_size(), v_b, ret)?;
-                    }
-                    _ => {
-                        if v_b != ret {
-                            self.machine.emit_relaxed_mov(Size::S64, v_b, ret)?;
-                        }
-                    }
+                if self.config.enable_nan_canonicalization
+                    && let Some(size) = canonicalize_b.to_size()
+                {
+                    self.machine.canonicalize_nan(size, v_b, ret)?;
+                } else if v_b != ret {
+                    self.machine.emit_relaxed_mov(Size::S64, v_b, ret)?;
                 }
                 self.machine.emit_label(end_label)?;
             }
             Operator::Block { blockty } => {
+                let return_types = self.return_types_for_block(blockty);
+                let param_types = self.param_types_for_block(blockty);
+                self.allocate_return_slots_and_swap(param_types.len(), return_types.len())?;
+
                 let frame = ControlFrame {
+                    state: ControlState::Block,
                     label: self.machine.get_label(),
-                    loop_like: false,
-                    if_else: IfElseState::None,
-                    returns: match blockty {
-                        WpTypeOrFuncType::Empty => smallvec![],
-                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
-                        _ => {
-                            return Err(CompileError::Codegen(
-                                "Block: multi-value returns not yet implemented".to_owned(),
-                            ))
-                        }
-                    },
+                    param_types,
+                    return_types,
                     value_stack_depth: self.value_stack.len(),
-                    fp_stack_depth: self.fp_stack.len(),
-                    state: self.state.clone(),
-                    state_diff_id: self.get_state_diff(),
                 };
                 self.control_stack.push(frame);
             }
             Operator::Loop { blockty } => {
                 self.machine.align_for_loop()?;
                 let label = self.machine.get_label();
-                let state_diff_id = self.get_state_diff();
-                let _activate_offset = self.machine.assembler_get_offset().0;
+
+                let return_types = self.return_types_for_block(blockty);
+                let param_types = self.param_types_for_block(blockty);
+                let params_count = param_types.len();
+                // We need extra space for params as we need to implement the PHI operation.
+                self.allocate_return_slots_and_swap(
+                    param_types.len(),
+                    param_types.len() + return_types.len(),
+                )?;
 
                 self.control_stack.push(ControlFrame {
+                    state: ControlState::Loop,
                     label,
-                    loop_like: true,
-                    if_else: IfElseState::None,
-                    returns: match blockty {
-                        WpTypeOrFuncType::Empty => smallvec![],
-                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
-                        _ => {
-                            return Err(CompileError::Codegen(
-                                "Loop: multi-value returns not yet implemented".to_owned(),
-                            ))
-                        }
-                    },
+                    param_types: param_types.clone(),
+                    return_types: return_types.clone(),
                     value_stack_depth: self.value_stack.len(),
-                    fp_stack_depth: self.fp_stack.len(),
-                    state: self.state.clone(),
-                    state_diff_id,
                 });
+
+                // For proper PHI implementation, we must copy pre-loop params to PHI params.
+                let params = self
+                    .value_stack
+                    .drain((self.value_stack.len() - params_count)..)
+                    .collect_vec();
+                for (param, phi_param) in params.iter().rev().zip(self.value_stack.iter().rev()) {
+                    self.machine
+                        .emit_relaxed_mov(Size::S64, param.0, phi_param.0)?;
+                }
+                self.release_locations(&params)?;
+
                 self.machine.emit_label(label)?;
 
+                // Put on the stack PHI inputs for further use.
+                let phi_params = self
+                    .value_stack
+                    .iter()
+                    .rev()
+                    .take(params_count)
+                    .rev()
+                    .copied()
+                    .collect_vec();
+                for (i, phi_param) in phi_params.into_iter().enumerate() {
+                    let loc = self.acquire_location(&param_types[i])?;
+                    self.machine.emit_relaxed_mov(Size::S64, phi_param.0, loc)?;
+                    self.value_stack.push((loc, phi_param.1));
+                }
+
                 // 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,
@@ -3137,33 +2626,27 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             },
                         ) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index]
-                    iter::once(Location::Imm32(memory_index.index() as u32)),
+                    iter::once((
+                        Location::Imm32(memory_index.index() as u32),
+                        CanonicalizeType::None,
+                    )),
                     iter::once(WpType::I64),
-                )?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S64,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I64),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::MemoryInit { data_index, mem } => {
                 let len = self.value_stack.pop().unwrap();
                 let src = self.value_stack.pop().unwrap();
                 let dst = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, src, dst])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -3173,21 +2656,18 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_memory_init_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, data_index, dst, src, len]
                     [
-                        Location::Imm32(mem),
-                        Location::Imm32(data_index),
+                        (Location::Imm32(mem), CanonicalizeType::None),
+                        (Location::Imm32(data_index), CanonicalizeType::None),
                         dst,
                         src,
                         len,
@@ -3203,8 +2683,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     ]
                     .iter()
                     .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-                self.release_locations_only_stack(&[dst, src, len])?;
             }
             Operator::DataDrop { data_index } => {
                 self.machine.move_location(
@@ -3215,26 +2696,26 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_data_drop_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, data_index]
-                    iter::once(Location::Imm32(data_index)),
+                    iter::once((Location::Imm32(data_index), CanonicalizeType::None)),
                     iter::once(WpType::I64),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
-            Operator::MemoryCopy { dst_mem, src_mem } => {
+            Operator::MemoryCopy { src_mem, .. } => {
                 // ignore until we support multiple memories
-                let _dst = dst_mem;
                 let len = self.value_stack.pop().unwrap();
                 let src_pos = self.value_stack.pop().unwrap();
                 let dst_pos = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, src_pos, dst_pos])?;
 
                 let memory_index = MemoryIndex::new(src_mem as usize);
                 let (memory_copy_index, memory_index) =
@@ -3256,20 +2737,20 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_builtin_function(memory_copy_index) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, dst, src, len]
                     [
-                        Location::Imm32(memory_index.index() as u32),
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
                         dst_pos,
                         src_pos,
                         len,
@@ -3279,14 +2760,14 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
                         .iter()
                         .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-                self.release_locations_only_stack(&[dst_pos, src_pos, len])?;
             }
             Operator::MemoryFill { mem } => {
                 let len = self.value_stack.pop().unwrap();
                 let val = self.value_stack.pop().unwrap();
                 let dst = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, val, dst])?;
 
                 let memory_index = MemoryIndex::new(mem as usize);
                 let (memory_fill_index, memory_index) =
@@ -3308,33 +2789,37 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_builtin_function(memory_fill_index) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, dst, src, len]
-                    [Location::Imm32(memory_index.index() as u32), dst, val, len]
-                        .iter()
-                        .cloned(),
+                    [
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
+                        dst,
+                        val,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
                         .iter()
                         .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-                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();
 
-                self.release_locations_only_regs(&[param_pages])?;
-
                 self.machine.move_location(
                     Size::S64,
                     Location::Memory(
@@ -3347,42 +2832,33 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             },
                         ) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, val, memory_index]
-                    iter::once(param_pages)
-                        .chain(iter::once(Location::Imm32(memory_index.index() as u32))),
+                    [
+                        param_pages,
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I64, WpType::I64].iter().cloned(),
-                )?;
-
-                self.release_locations_only_stack(&[param_pages])?;
-
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S64,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I64),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::I32Load { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3404,14 +2880,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::F32Load { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3433,12 +2904,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Load8U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3460,12 +2928,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Load8S { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3487,12 +2952,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Load16U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3514,12 +2976,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Load16S { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3541,8 +3000,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Store { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3564,10 +3023,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::F32Store { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
-                let fp = self.fp_stack.pop1()?;
-                let config_nan_canonicalization = self.config.enable_nan_canonicalization;
+                let (target_value, canonicalize) = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3579,7 +3036,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             target_value,
                             memarg,
                             target_addr,
-                            config_nan_canonicalization && fp.canonicalization.is_some(),
+                            self.config.enable_nan_canonicalization
+                                && !matches!(canonicalize, CanonicalizeType::None),
                             need_check,
                             imported_memories,
                             offset,
@@ -3590,8 +3048,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Store8 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3613,8 +3071,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32Store16 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3636,12 +3094,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3663,14 +3118,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::F64Load { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.fp_stack
-                    .push(FloatValue::new(self.value_stack.len() - 1));
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::F64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3692,12 +3142,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load8U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3719,12 +3166,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load8S { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3746,12 +3190,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load16U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3773,12 +3214,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load16S { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3800,12 +3238,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load32U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3827,12 +3262,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Load32S { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -3854,8 +3286,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Store { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
 
                 self.op_memory(
                     |this,
@@ -3878,10 +3310,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::F64Store { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
-                let fp = self.fp_stack.pop1()?;
-                let config_nan_canonicalization = self.config.enable_nan_canonicalization;
+                let (target_value, canonicalize) = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3893,7 +3323,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             target_value,
                             memarg,
                             target_addr,
-                            config_nan_canonicalization && fp.canonicalization.is_some(),
+                            self.config.enable_nan_canonicalization
+                                && !matches!(canonicalize, CanonicalizeType::None),
                             need_check,
                             imported_memories,
                             offset,
@@ -3904,8 +3335,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Store8 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3927,8 +3358,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Store16 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3950,8 +3381,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64Store32 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -3973,105 +3404,109 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::Unreachable => {
-                self.mark_trappable();
-                self.machine
-                    .emit_illegal_op(TrapCode::UnreachableCodeReached)?;
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_raise_trap_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_gpr_for_call()),
+                )?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_gpr_for_call())
+                    },
+                    // [trap_code]
+                    [(
+                        Location::Imm32(TrapCode::UnreachableCodeReached as u32),
+                        CanonicalizeType::None,
+                    )]
+                    .iter()
+                    .cloned(),
+                    [WpType::I32].iter().cloned(),
+                    iter::empty(),
+                    NativeCallType::Unreachable,
+                )?;
                 self.unreachable_depth = 1;
             }
             Operator::Return => {
                 let frame = &self.control_stack[0];
-                if !frame.returns.is_empty() {
-                    if frame.returns.len() != 1 {
-                        return Err(CompileError::Codegen(
-                            "Return: incorrect frame.returns".to_owned(),
-                        ));
-                    }
-                    let first_return = frame.returns[0];
-                    let loc = *self.value_stack.last().unwrap();
-                    let canonicalize = if first_return.is_float() {
-                        let fp = self.fp_stack.peek1()?;
-                        self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
-                    } else {
-                        false
-                    };
-                    self.machine
-                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                if !frame.return_types.is_empty() {
+                    self.emit_return_values(
+                        frame.value_stack_depth_after(),
+                        frame.return_types.len(),
+                    )?;
                 }
                 let frame = &self.control_stack[0];
-                let frame_depth = frame.value_stack_depth;
+                let frame_depth = frame.value_stack_depth_for_release();
                 let label = frame.label;
-                self.release_locations_keep_state(frame_depth)?;
-                self.machine.jmp_unconditionnal(label)?;
+                self.release_stack_locations_keep_stack_offset(frame_depth)?;
+                self.machine.jmp_unconditional(label)?;
                 self.unreachable_depth = 1;
             }
             Operator::Br { relative_depth } => {
                 let frame =
                     &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)];
-                if !frame.loop_like && !frame.returns.is_empty() {
-                    if frame.returns.len() != 1 {
-                        return Err(CompileError::Codegen(
-                            "Br: incorrect frame.returns".to_owned(),
-                        ));
-                    }
-                    let first_return = frame.returns[0];
-                    let loc = *self.value_stack.last().unwrap();
-                    let canonicalize = if first_return.is_float() {
-                        let fp = self.fp_stack.peek1()?;
-                        self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
+                if !frame.return_types.is_empty() {
+                    if matches!(frame.state, ControlState::Loop) {
+                        // Store into the PHI params of the loop, not to the return values.
+                        self.emit_loop_params_store(
+                            frame.value_stack_depth_after(),
+                            frame.param_types.len(),
+                        )?;
                     } else {
-                        false
-                    };
-                    self.machine
-                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                        self.emit_return_values(
+                            frame.value_stack_depth_after(),
+                            frame.return_types.len(),
+                        )?;
+                    }
                 }
                 let stack_len = self.control_stack.len();
                 let frame = &mut self.control_stack[stack_len - 1 - (relative_depth as usize)];
-                let frame_depth = frame.value_stack_depth;
+                let frame_depth = frame.value_stack_depth_for_release();
                 let label = frame.label;
 
-                self.release_locations_keep_state(frame_depth)?;
-                self.machine.jmp_unconditionnal(label)?;
+                self.release_stack_locations_keep_stack_offset(frame_depth)?;
+                self.machine.jmp_unconditional(label)?;
                 self.unreachable_depth = 1;
             }
             Operator::BrIf { relative_depth } => {
                 let after = self.machine.get_label();
-                let cond = self.pop_value_released()?;
-                self.machine
-                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
-                self.machine.jmp_on_equal(after)?;
+                let cond = self.pop_value_released()?.0;
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::Equal,
+                    Size::S32,
+                    cond,
+                    Location::Imm32(0),
+                    after,
+                )?;
 
                 let frame =
                     &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)];
-                if !frame.loop_like && !frame.returns.is_empty() {
-                    if frame.returns.len() != 1 {
-                        return Err(CompileError::Codegen(
-                            "BrIf: incorrect frame.returns".to_owned(),
-                        ));
-                    }
-
-                    let first_return = frame.returns[0];
-                    let loc = *self.value_stack.last().unwrap();
-                    let canonicalize = if first_return.is_float() {
-                        let fp = self.fp_stack.peek1()?;
-                        self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
+                if !frame.return_types.is_empty() {
+                    if matches!(frame.state, ControlState::Loop) {
+                        // Store into the PHI params of the loop, not to the return values.
+                        self.emit_loop_params_store(
+                            frame.value_stack_depth_after(),
+                            frame.param_types.len(),
+                        )?;
                     } else {
-                        false
-                    };
-                    self.machine
-                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                        self.emit_return_values(
+                            frame.value_stack_depth_after(),
+                            frame.return_types.len(),
+                        )?;
+                    }
                 }
                 let stack_len = self.control_stack.len();
                 let frame = &mut self.control_stack[stack_len - 1 - (relative_depth as usize)];
-                let stack_depth = frame.value_stack_depth;
+                let stack_depth = frame.value_stack_depth_for_release();
                 let label = frame.label;
-                self.release_locations_keep_state(stack_depth)?;
-                self.machine.jmp_unconditionnal(label)?;
+                self.release_stack_locations_keep_stack_offset(stack_depth)?;
+                self.machine.jmp_unconditional(label)?;
 
                 self.machine.emit_label(after)?;
             }
@@ -4080,17 +3515,18 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 let targets = targets
                     .targets()
                     .collect::<Result<Vec<_>, _>>()
-                    .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {:?}", e)))?;
-                let cond = self.pop_value_released()?;
+                    .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {e:?}")))?;
+                let cond = self.pop_value_released()?.0;
                 let table_label = self.machine.get_label();
                 let mut table: Vec<Label> = vec![];
                 let default_br = self.machine.get_label();
-                self.machine.emit_relaxed_cmp(
+                self.machine.jmp_on_condition(
+                    UnsignedCondition::AboveEqual,
                     Size::S32,
-                    Location::Imm32(targets.len() as u32),
                     cond,
+                    Location::Imm32(targets.len() as u32),
+                    default_br,
                 )?;
-                self.machine.jmp_on_aboveequal(default_br)?;
 
                 self.machine.emit_jmp_to_jumptable(table_label, cond)?;
 
@@ -4100,96 +3536,71 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     table.push(label);
                     let frame =
                         &self.control_stack[self.control_stack.len() - 1 - (*target as usize)];
-                    if !frame.loop_like && !frame.returns.is_empty() {
-                        if frame.returns.len() != 1 {
-                            return Err(CompileError::Codegen(format!(
-                                "BrTable: incorrect frame.returns for {:?}",
-                                target
-                            )));
-                        }
-
-                        let first_return = frame.returns[0];
-                        let loc = *self.value_stack.last().unwrap();
-                        let canonicalize = if first_return.is_float() {
-                            let fp = self.fp_stack.peek1()?;
-                            self.machine.arch_supports_canonicalize_nan()
-                                && self.config.enable_nan_canonicalization
-                                && fp.canonicalization.is_some()
+                    if !frame.return_types.is_empty() {
+                        if matches!(frame.state, ControlState::Loop) {
+                            // Store into the PHI params of the loop, not to the return values.
+                            self.emit_loop_params_store(
+                                frame.value_stack_depth_after(),
+                                frame.param_types.len(),
+                            )?;
                         } else {
-                            false
-                        };
-                        self.machine
-                            .emit_function_return_value(first_return, canonicalize, loc)?;
+                            self.emit_return_values(
+                                frame.value_stack_depth_after(),
+                                frame.return_types.len(),
+                            )?;
+                        }
                     }
                     let frame =
                         &self.control_stack[self.control_stack.len() - 1 - (*target as usize)];
-                    let stack_depth = frame.value_stack_depth;
+                    let stack_depth = frame.value_stack_depth_for_release();
                     let label = frame.label;
-                    self.release_locations_keep_state(stack_depth)?;
-                    self.machine.jmp_unconditionnal(label)?;
+                    self.release_stack_locations_keep_stack_offset(stack_depth)?;
+                    self.machine.jmp_unconditional(label)?;
                 }
                 self.machine.emit_label(default_br)?;
 
                 {
                     let frame = &self.control_stack
                         [self.control_stack.len() - 1 - (default_target as usize)];
-                    if !frame.loop_like && !frame.returns.is_empty() {
-                        if frame.returns.len() != 1 {
-                            return Err(CompileError::Codegen(
-                                "BrTable: incorrect frame.returns".to_owned(),
-                            ));
-                        }
-
-                        let first_return = frame.returns[0];
-                        let loc = *self.value_stack.last().unwrap();
-                        let canonicalize = if first_return.is_float() {
-                            let fp = self.fp_stack.peek1()?;
-                            self.machine.arch_supports_canonicalize_nan()
-                                && self.config.enable_nan_canonicalization
-                                && fp.canonicalization.is_some()
+                    if !frame.return_types.is_empty() {
+                        if matches!(frame.state, ControlState::Loop) {
+                            // Store into the PHI params of the loop, not to the return values.
+                            self.emit_loop_params_store(
+                                frame.value_stack_depth_after(),
+                                frame.param_types.len(),
+                            )?;
                         } else {
-                            false
-                        };
-                        self.machine
-                            .emit_function_return_value(first_return, canonicalize, loc)?;
+                            self.emit_return_values(
+                                frame.value_stack_depth_after(),
+                                frame.return_types.len(),
+                            )?;
+                        }
                     }
                     let frame = &self.control_stack
                         [self.control_stack.len() - 1 - (default_target as usize)];
-                    let stack_depth = frame.value_stack_depth;
+                    let stack_depth = frame.value_stack_depth_for_release();
                     let label = frame.label;
-                    self.release_locations_keep_state(stack_depth)?;
-                    self.machine.jmp_unconditionnal(label)?;
+                    self.release_stack_locations_keep_stack_offset(stack_depth)?;
+                    self.machine.jmp_unconditional(label)?;
                 }
 
                 self.machine.emit_label(table_label)?;
                 for x in table {
-                    self.machine.jmp_unconditionnal(x)?;
+                    self.machine.jmp_unconditional(x)?;
                 }
                 self.unreachable_depth = 1;
             }
             Operator::Drop => {
                 self.pop_value_released()?;
-                if let Some(x) = self.fp_stack.last() {
-                    if x.depth == self.value_stack.len() {
-                        self.fp_stack.pop1()?;
-                    }
-                }
             }
             Operator::End => {
                 let frame = self.control_stack.pop().unwrap();
 
-                if !was_unreachable && !frame.returns.is_empty() {
-                    let loc = *self.value_stack.last().unwrap();
-                    let canonicalize = if frame.returns[0].is_float() {
-                        let fp = self.fp_stack.peek1()?;
-                        self.machine.arch_supports_canonicalize_nan()
-                            && self.config.enable_nan_canonicalization
-                            && fp.canonicalization.is_some()
-                    } else {
-                        false
-                    };
-                    self.machine
-                        .emit_function_return_value(frame.returns[0], canonicalize, loc)?;
+                if !was_unreachable && !frame.return_types.is_empty() {
+                    self.emit_return_values(
+                        frame.value_stack_depth_after(),
+                        frame.return_types.len(),
+                    )?;
                 }
 
                 if self.control_stack.is_empty() {
@@ -4198,52 +3609,27 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     self.machine.emit_function_epilog()?;
 
                     // Make a copy of the return value in XMM0, as required by the SysV CC.
-                    match self.signature.results() {
-                        [x] if *x == Type::F32 || *x == Type::F64 => {
-                            self.machine.emit_function_return_float()?;
-                        }
-                        _ => {}
+                    #[allow(clippy::collapsible_if, reason = "hard to read otherwise")]
+                    if let Ok(&return_type) = self.signature.results().iter().exactly_one()
+                        && (return_type == Type::F32 || return_type == Type::F64)
+                    {
+                        self.machine.emit_function_return_float()?;
                     }
                     self.machine.emit_ret()?;
                 } else {
-                    let released = &self.value_stack.clone()[frame.value_stack_depth..];
+                    let released = &self.value_stack.clone()[frame.value_stack_depth_after()..];
                     self.release_locations(released)?;
-                    self.value_stack.truncate(frame.value_stack_depth);
-                    self.fp_stack.truncate(frame.fp_stack_depth);
+                    self.value_stack.truncate(frame.value_stack_depth_after());
 
-                    if !frame.loop_like {
+                    if !matches!(frame.state, ControlState::Loop) {
                         self.machine.emit_label(frame.label)?;
                     }
 
-                    if let IfElseState::If(label) = frame.if_else {
-                        self.machine.emit_label(label)?;
+                    if let ControlState::If { label_else, .. } = frame.state {
+                        self.machine.emit_label(label_else)?;
                     }
 
-                    if !frame.returns.is_empty() {
-                        if frame.returns.len() != 1 {
-                            return Err(CompileError::Codegen(
-                                "End: incorrect frame.returns".to_owned(),
-                            ));
-                        }
-                        let loc = self.acquire_locations(
-                            &[(
-                                frame.returns[0],
-                                MachineValue::WasmStack(self.value_stack.len()),
-                            )],
-                            false,
-                        )?[0];
-                        self.machine.move_location(
-                            Size::S64,
-                            Location::GPR(self.machine.get_gpr_for_ret()),
-                            loc,
-                        )?;
-                        self.value_stack.push(loc);
-                        if frame.returns[0].is_float() {
-                            self.fp_stack
-                                .push(FloatValue::new(self.value_stack.len() - 1));
-                            // we already canonicalized at the `Br*` instruction or here previously.
-                        }
-                    }
+                    // At this point the return values are properly sitting in the value_stack and are properly canonicalized.
                 }
             }
             Operator::AtomicFence => {
@@ -4257,12 +3643,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 self.machine.emit_memory_fence()?;
             }
             Operator::I32AtomicLoad { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4284,12 +3667,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicLoad8U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4311,12 +3691,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicLoad16U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4338,8 +3715,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicStore { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4361,8 +3738,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicStore8 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4384,8 +3761,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicStore16 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4407,12 +3784,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicLoad { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4434,12 +3808,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicLoad8U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4461,12 +3832,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicLoad16U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4488,12 +3856,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicLoad32U { ref memarg } => {
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4515,8 +3880,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicStore { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4538,8 +3903,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicStore8 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4561,8 +3926,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicStore16 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4584,8 +3949,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicStore32 { ref memarg } => {
-                let target_value = self.pop_value_released()?;
-                let target_addr = self.pop_value_released()?;
+                let target_value = self.pop_value_released()?.0;
+                let target_addr = self.pop_value_released()?.0;
                 self.op_memory(
                     |this,
                      need_check,
@@ -4607,13 +3972,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwAdd { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4636,13 +3998,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwAdd { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4665,13 +4024,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8AddU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4694,13 +4050,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16AddU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4723,13 +4076,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8AddU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4752,13 +4102,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16AddU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4781,13 +4128,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32AddU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4810,13 +4154,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwSub { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4839,13 +4180,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwSub { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4868,13 +4206,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8SubU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4897,13 +4232,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16SubU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4926,13 +4258,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8SubU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4955,13 +4284,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16SubU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -4984,13 +4310,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32SubU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5013,13 +4336,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwAnd { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5042,13 +4362,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwAnd { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5071,13 +4388,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8AndU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5100,13 +4414,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16AndU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5129,13 +4440,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8AndU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5158,13 +4466,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16AndU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5187,13 +4492,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32AndU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5216,13 +4518,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwOr { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5245,13 +4544,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwOr { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5274,13 +4570,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8OrU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5303,13 +4596,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16OrU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5332,13 +4622,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8OrU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5361,13 +4648,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16OrU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5390,13 +4674,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32OrU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5419,13 +4700,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwXor { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5448,13 +4726,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwXor { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5477,13 +4752,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8XorU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5506,13 +4778,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16XorU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5535,13 +4804,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8XorU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5564,13 +4830,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16XorU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5593,13 +4856,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32XorU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5622,13 +4882,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwXchg { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5651,13 +4908,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwXchg { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5680,13 +4934,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8XchgU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5709,13 +4960,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16XchgU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5738,13 +4986,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8XchgU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5767,13 +5012,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16XchgU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5796,13 +5038,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32XchgU { ref memarg } => {
-                let loc = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let loc = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5825,14 +5064,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmwCmpxchg { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5856,14 +5092,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmwCmpxchg { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5887,14 +5120,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw8CmpxchgU { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5918,14 +5148,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I32AtomicRmw16CmpxchgU { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5949,14 +5176,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw8CmpxchgU { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -5980,14 +5204,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw16CmpxchgU { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -6011,14 +5232,11 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
             }
             Operator::I64AtomicRmw32CmpxchgU { ref memarg } => {
-                let new = self.pop_value_released()?;
-                let cmp = self.pop_value_released()?;
-                let target = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
+                let new = self.pop_value_released()?.0;
+                let cmp = self.pop_value_released()?.0;
+                let target = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I64)?;
+                self.value_stack.push((ret, CanonicalizeType::None));
                 self.op_memory(
                     |this,
                      need_check,
@@ -6043,8 +5261,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
 
             Operator::RefNull { .. } => {
-                self.value_stack.push(Location::Imm64(0));
-                self.state.wasm_stack.push(WasmAbstractValue::Const(0));
+                self.value_stack
+                    .push((Location::Imm64(0), CanonicalizeType::None));
             }
             Operator::RefFunc { function_index } => {
                 self.machine.move_location(
@@ -6055,50 +5273,34 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_func_ref_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: unclear if we need this? check other new insts with no stack ops
-                //.machine.release_locations_only_osr_state(1);
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, func_index] -> funcref
-                    iter::once(Location::Imm32(function_index as u32)),
+                    iter::once((
+                        Location::Imm32(function_index as u32),
+                        CanonicalizeType::None,
+                    )),
                     iter::once(WpType::I64),
-                )?;
-
-                let ret = self.acquire_locations(
-                    &[(
-                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
-                        MachineValue::WasmStack(self.value_stack.len()),
-                    )],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S64,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::Ref(WpRefType::new(true, WpHeapType::FUNC).unwrap())),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::RefIsNull => {
-                let loc_a = self.pop_value_released()?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
+                let loc_a = self.pop_value_released()?.0;
+                let ret = self.acquire_location(&WpType::I32)?;
                 self.machine.i64_cmp_eq(loc_a, Location::Imm64(0), ret)?;
-                self.value_stack.push(ret);
+                self.value_stack.push((ret, CanonicalizeType::None));
             }
             Operator::TableSet { table: index } => {
                 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])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -6112,29 +5314,33 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             },
                         ) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 2?
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, table_index, elem_index, reftype]
-                    [Location::Imm32(table_index.index() as u32), index, value]
-                        .iter()
-                        .cloned(),
+                    [
+                        (
+                            Location::Imm32(table_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
+                        index,
+                        value,
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I32, WpType::I64, WpType::I64].iter().cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&[index, value])?;
             }
             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(
                     Size::S64,
@@ -6148,36 +5354,27 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             },
                         ) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, table_index, elem_index] -> reftype
-                    [Location::Imm32(table_index.index() as u32), index]
-                        .iter()
-                        .cloned(),
+                    [
+                        (
+                            Location::Imm32(table_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
+                        index,
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I32, WpType::I64].iter().cloned(),
-                )?;
-
-                self.release_locations_only_stack(&[index])?;
-
-                let ret = self.acquire_locations(
-                    &[(
-                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
-                        MachineValue::WasmStack(self.value_stack.len()),
-                    )],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S64,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::Ref(WpRefType::new(true, WpHeapType::FUNC).unwrap())),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::TableSize { table: index } => {
@@ -6195,35 +5392,28 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             },
                         ) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, table_index] -> i32
-                    iter::once(Location::Imm32(table_index.index() as u32)),
+                    iter::once((
+                        Location::Imm32(table_index.index() as u32),
+                        CanonicalizeType::None,
+                    )),
                     iter::once(WpType::I32),
-                )?;
-
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S32,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I32),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::TableGrow { table: index } => {
                 let table_index = TableIndex::new(index as _);
                 let delta = self.value_stack.pop().unwrap();
                 let init_value = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[delta, init_value])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -6233,42 +5423,32 @@ 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,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 2?
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, init_value, delta, table_index] -> u32
                     [
                         init_value,
                         delta,
-                        Location::Imm32(table_index.index() as u32),
+                        (
+                            Location::Imm32(table_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
                     ]
                     .iter()
                     .cloned(),
                     [WpType::I64, WpType::I64, WpType::I64].iter().cloned(),
-                )?;
-
-                self.release_locations_only_stack(&[init_value, delta])?;
-
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S32,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I32),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::TableCopy {
@@ -6278,7 +5458,6 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 let len = self.value_stack.pop().unwrap();
                 let src = self.value_stack.pop().unwrap();
                 let dest = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, src, dest])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -6288,20 +5467,18 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_copy_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, dst_table_index, src_table_index, dst, src, len]
                     [
-                        Location::Imm32(dst_table),
-                        Location::Imm32(src_table),
+                        (Location::Imm32(dst_table), CanonicalizeType::None),
+                        (Location::Imm32(src_table), CanonicalizeType::None),
                         dest,
                         src,
                         len,
@@ -6317,16 +5494,15 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     ]
                     .iter()
                     .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&[dest, src, len])?;
             }
 
             Operator::TableFill { table } => {
                 let len = self.value_stack.pop().unwrap();
                 let val = self.value_stack.pop().unwrap();
                 let dest = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, val, dest])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -6336,30 +5512,34 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_fill_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, table_index, start_idx, item, len]
-                    [Location::Imm32(table), dest, val, len].iter().cloned(),
+                    [
+                        (Location::Imm32(table), CanonicalizeType::None),
+                        dest,
+                        val,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
                         .iter()
                         .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&[dest, val, len])?;
             }
             Operator::TableInit { elem_index, table } => {
                 let len = self.value_stack.pop().unwrap();
                 let src = self.value_stack.pop().unwrap();
                 let dest = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[len, src, dest])?;
 
                 self.machine.move_location(
                     Size::S64,
@@ -6369,20 +5549,18 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_init_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, table_index, elem_index, dst, src, len]
                     [
-                        Location::Imm32(table),
-                        Location::Imm32(elem_index),
+                        (Location::Imm32(table), CanonicalizeType::None),
+                        (Location::Imm32(elem_index), CanonicalizeType::None),
                         dest,
                         src,
                         len,
@@ -6398,9 +5576,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     ]
                     .iter()
                     .cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
-
-                self.release_locations_only_stack(&[dest, src, len])?;
             }
             Operator::ElemDrop { elem_index } => {
                 self.machine.move_location(
@@ -6411,26 +5589,25 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             .vmctx_builtin_function(VMBuiltinFunctionIndex::get_elem_drop_index())
                             as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: do we need this?
-                //.machine.release_locations_only_osr_state(1);
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, elem_index]
-                    [Location::Imm32(elem_index)].iter().cloned(),
+                    iter::once((Location::Imm32(elem_index), CanonicalizeType::None)),
                     [WpType::I32].iter().cloned(),
+                    iter::empty(),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::MemoryAtomicWait32 { ref memarg } => {
                 let timeout = self.value_stack.pop().unwrap();
                 let val = self.value_stack.pop().unwrap();
                 let dst = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[timeout, val, dst])?;
 
                 let memory_index = MemoryIndex::new(memarg.memory as usize);
                 let (memory_atomic_wait32, memory_index) =
@@ -6452,20 +5629,20 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_builtin_function(memory_atomic_wait32) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, dst, src, timeout]
                     [
-                        Location::Imm32(memory_index.index() as u32),
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
                         dst,
                         val,
                         timeout,
@@ -6475,24 +5652,14 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     [WpType::I32, WpType::I32, WpType::I32, WpType::I64]
                         .iter()
                         .cloned(),
-                )?;
-                self.release_locations_only_stack(&[dst, val, timeout])?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S32,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I32),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::MemoryAtomicWait64 { ref memarg } => {
                 let timeout = self.value_stack.pop().unwrap();
                 let val = self.value_stack.pop().unwrap();
                 let dst = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[timeout, val, dst])?;
 
                 let memory_index = MemoryIndex::new(memarg.memory as usize);
                 let (memory_atomic_wait64, memory_index) =
@@ -6514,20 +5681,20 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_builtin_function(memory_atomic_wait64) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, dst, src, timeout]
                     [
-                        Location::Imm32(memory_index.index() as u32),
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
                         dst,
                         val,
                         timeout,
@@ -6537,23 +5704,13 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     [WpType::I32, WpType::I32, WpType::I64, WpType::I64]
                         .iter()
                         .cloned(),
-                )?;
-                self.release_locations_only_stack(&[dst, val, timeout])?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S32,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I32),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             Operator::MemoryAtomicNotify { ref memarg } => {
-                let cnt = self.value_stack.pop().unwrap();
+                let _cnt = self.value_stack.pop().unwrap();
                 let dst = self.value_stack.pop().unwrap();
-                self.release_locations_only_regs(&[cnt, dst])?;
 
                 let memory_index = MemoryIndex::new(memarg.memory as usize);
                 let (memory_atomic_notify, memory_index) =
@@ -6575,39 +5732,32 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         self.machine.get_vmctx_reg(),
                         self.vmoffsets.vmctx_builtin_function(memory_atomic_notify) as i32,
                     ),
-                    Location::GPR(self.machine.get_grp_for_call()),
+                    Location::GPR(self.machine.get_gpr_for_call()),
                 )?;
 
-                // TODO: should this be 3?
-                self.release_locations_only_osr_state(1)?;
-
                 self.emit_call_native(
                     |this| {
                         this.machine
-                            .emit_call_register(this.machine.get_grp_for_call())
+                            .emit_call_register(this.machine.get_gpr_for_call())
                     },
                     // [vmctx, memory_index, dst, src, timeout]
-                    [Location::Imm32(memory_index.index() as u32), dst]
-                        .iter()
-                        .cloned(),
+                    [
+                        (
+                            Location::Imm32(memory_index.index() as u32),
+                            CanonicalizeType::None,
+                        ),
+                        dst,
+                    ]
+                    .iter()
+                    .cloned(),
                     [WpType::I32, WpType::I32].iter().cloned(),
-                )?;
-                self.release_locations_only_stack(&[dst, cnt])?;
-                let ret = self.acquire_locations(
-                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
-                    false,
-                )?[0];
-                self.value_stack.push(ret);
-                self.machine.move_location(
-                    Size::S32,
-                    Location::GPR(self.machine.get_gpr_for_ret()),
-                    ret,
+                    iter::once(WpType::I32),
+                    NativeCallType::IncludeVMCtxArgument,
                 )?;
             }
             _ => {
                 return Err(CompileError::Codegen(format!(
-                    "not yet implemented: {:?}",
-                    op
+                    "not yet implemented: {op:?}"
                 )));
             }
         }
@@ -6615,10 +5765,20 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         Ok(())
     }
 
+    fn add_assembly_comment(&mut self, comment: AssemblyComment) {
+        // Collect assembly comments only if we're going to emit them.
+        if self.config.callbacks.is_some() {
+            self.assembly_comments
+                .insert(self.machine.get_offset().0, comment);
+        }
+    }
+
     pub fn finalize(
         mut self,
         data: &FunctionBodyData,
+        arch: Architecture,
     ) -> Result<(CompiledFunction, Option<UnwindFrame>), CompileError> {
+        self.add_assembly_comment(AssemblyComment::TrapHandlersTable);
         // Generate actual code for special labels.
         self.machine
             .emit_label(self.special_labels.integer_division_by_zero)?;
@@ -6655,7 +5815,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
         let body_len = self.machine.assembler_get_offset().0;
 
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
         let mut unwind_info = None;
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
         let mut fde = None;
         #[cfg(feature = "unwind")]
         match self.calling_convention {
@@ -6664,7 +5826,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 if let Some(unwind) = unwind {
                     fde = Some(unwind.to_fde(Address::Symbol {
                         symbol: WriterRelocate::FUNCTION_SYMBOL,
-                        addend: self.fsm.local_function_id as _,
+                        addend: self.local_func_index.index() as _,
                     }));
                     unwind_info = Some(CompiledFunctionUnwindInfo::Dwarf);
                 }
@@ -6681,9 +5843,27 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         let address_map =
             get_function_address_map(self.machine.instructions_address_map(), data, body_len);
         let traps = self.machine.collect_trap_information();
-        let mut body = self.machine.assembler_finalize()?;
+        let FinalizedAssembly {
+            mut body,
+            assembly_comments,
+        } = self.machine.assembler_finalize(self.assembly_comments)?;
         body.shrink_to_fit();
 
+        if let Some(callbacks) = self.config.callbacks.as_ref() {
+            callbacks.obj_memory_buffer(
+                &CompiledKind::Local(self.local_func_index, self.function_name.clone()),
+                &self.module.hash_string(),
+                &body,
+            );
+            callbacks.asm_memory_buffer(
+                &CompiledKind::Local(self.local_func_index, self.function_name.clone()),
+                &self.module.hash_string(),
+                arch,
+                &body,
+                assembly_comments,
+            )?;
+        }
+
         Ok((
             CompiledFunction {
                 body: FunctionBody { body, unwind_info },
@@ -6699,10 +5879,10 @@ impl<'a, M: Machine> FuncGen<'a, M> {
     fn sort_call_movs(movs: &mut [(Location<M::GPR, M::SIMD>, M::GPR)]) {
         for i in 0..movs.len() {
             for j in (i + 1)..movs.len() {
-                if let Location::GPR(src_gpr) = movs[j].0 {
-                    if src_gpr == movs[i].1 {
-                        movs.swap(i, j);
-                    }
+                if let Location::GPR(src_gpr) = movs[j].0
+                    && src_gpr == movs[i].1
+                {
+                    movs.swap(i, j);
                 }
             }
         }
diff --git a/lib/compiler-singlepass/src/common_decl.rs b/lib/compiler-singlepass/src/common_decl.rs
index 9d48cf6933..6555d1fdaa 100644
--- a/lib/compiler-singlepass/src/common_decl.rs
+++ b/lib/compiler-singlepass/src/common_decl.rs
@@ -1,111 +1,3 @@
-use std::collections::BTreeMap;
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct RegisterIndex(pub usize);
-
-/// Whether a value is determined at compile-time or run-time.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub enum WasmAbstractValue {
-    /// This value is only known at runtime.
-    Runtime,
-    /// A constant value.
-    Const(u64),
-}
-
-/// A container for the state of a running wasm instance.
-#[derive(Clone, Debug)]
-pub struct MachineState {
-    /// Stack values.
-    pub stack_values: Vec<MachineValue>,
-    /// Register values.
-    pub register_values: Vec<MachineValue>,
-    /// Previous frame.
-    pub prev_frame: BTreeMap<usize, MachineValue>,
-    /// Wasm stack.
-    pub wasm_stack: Vec<WasmAbstractValue>,
-    /// Wasm instruction offset.
-    pub wasm_inst_offset: usize,
-}
-
-/// A diff of two `MachineState`s.
-///
-/// A `MachineStateDiff` can only be applied after the `MachineStateDiff` its `last` field
-/// points to is already applied.
-#[derive(Clone, Debug, Default)]
-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>,
-
-    /// What values are pushed onto the stack?
-    pub stack_push: Vec<MachineValue>,
-
-    /// How many values are popped from the stack?
-    pub stack_pop: usize,
-
-    /// Register diff.
-    pub reg_diff: Vec<(RegisterIndex, MachineValue)>,
-
-    /// Changes in the previous frame's data.
-    pub prev_frame_diff: BTreeMap<usize, Option<MachineValue>>, // None for removal
-
-    /// Values pushed to the Wasm stack.
-    pub wasm_stack_push: Vec<WasmAbstractValue>,
-
-    /// # of values popped from the Wasm stack.
-    pub wasm_stack_pop: usize,
-
-    /// Wasm instruction offset.
-    pub wasm_inst_offset: usize, // absolute value; not a diff.
-}
-
-/// A kind of machine value.
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
-pub enum MachineValue {
-    /// Undefined.
-    Undefined,
-    /// Vmctx.
-    Vmctx,
-    /// Vmctx Deref.
-    _VmctxDeref(Vec<usize>),
-    /// Preserve Register.
-    PreserveRegister(RegisterIndex),
-    /// Copy Stack BP Relative.
-    CopyStackBPRelative(i32), // relative to Base Pointer, in byte offset
-    /// Explicit Shadow.
-    ExplicitShadow, // indicates that all values above this are above the shadow region
-    /// Wasm Stack.
-    WasmStack(usize),
-    /// Wasm Local.
-    WasmLocal(usize),
-    /// Two Halves.
-    _TwoHalves(Box<(MachineValue, MachineValue)>), // 32-bit values. TODO: optimize: add another type for inner "half" value to avoid boxing?
-}
-
-/// A map of function states.
-#[derive(Clone, Debug)]
-pub struct FunctionStateMap {
-    /// Initial.
-    pub initial: MachineState,
-    /// Local Function Id.
-    pub local_function_id: usize,
-    /// Locals.
-    pub locals: Vec<WasmAbstractValue>,
-    /// Shadow size.
-    pub shadow_size: usize, // for single-pass backend, 32 bytes on x86-64
-    /// Diffs.
-    pub diffs: Vec<MachineStateDiff>,
-    /// Wasm Function Header target offset.
-    pub wasm_function_header_target_offset: Option<SuspendOffset>,
-    /// Wasm offset to target offset
-    pub wasm_offset_to_target_offset: BTreeMap<usize, SuspendOffset>,
-    /// Loop offsets.
-    pub loop_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
-    /// Call offsets.
-    pub call_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
-    /// Trappable offsets.
-    pub trappable_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
-}
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub enum Size {
     S8,
@@ -114,150 +6,17 @@ pub enum Size {
     S64,
 }
 
-/// A kind of suspend offset.
-#[derive(Clone, Copy, Debug)]
-pub enum SuspendOffset {
-    /// A loop.
-    _Loop(usize),
-    /// A call.
-    Call(usize),
-    /// A trappable.
-    Trappable(usize),
-}
-
-/// Description of a machine code range following an offset.
-#[derive(Clone, Debug)]
-pub struct OffsetInfo {
-    /// Exclusive range-end offset.
-    pub end_offset: usize,
-    /// Index pointing to the `MachineStateDiff` entry.
-    pub diff_id: usize,
-    /// Offset at which execution can be continued.
-    pub activate_offset: usize,
-}
-
-impl FunctionStateMap {
-    /// Creates a new `FunctionStateMap` with the given parameters.
-    pub fn new(
-        initial: MachineState,
-        local_function_id: usize,
-        shadow_size: usize,
-        locals: Vec<WasmAbstractValue>,
-    ) -> FunctionStateMap {
-        FunctionStateMap {
-            initial,
-            local_function_id,
-            shadow_size,
-            locals,
-            diffs: vec![],
-            wasm_function_header_target_offset: None,
-            wasm_offset_to_target_offset: BTreeMap::new(),
-            loop_offsets: BTreeMap::new(),
-            call_offsets: BTreeMap::new(),
-            trappable_offsets: BTreeMap::new(),
-        }
-    }
-}
-
-impl MachineState {
-    /// Creates a `MachineStateDiff` from self and the given `&MachineState`.
-    pub fn diff(&self, old: &MachineState) -> MachineStateDiff {
-        let first_diff_stack_depth: usize = self
-            .stack_values
-            .iter()
-            .zip(old.stack_values.iter())
-            .enumerate()
-            .find(|&(_, (a, b))| a != b)
-            .map(|x| x.0)
-            .unwrap_or_else(|| old.stack_values.len().min(self.stack_values.len()));
-        assert_eq!(self.register_values.len(), old.register_values.len());
-        let reg_diff: Vec<_> = self
-            .register_values
-            .iter()
-            .zip(old.register_values.iter())
-            .enumerate()
-            .filter(|&(_, (a, b))| a != b)
-            .map(|(i, (a, _))| (RegisterIndex(i), a.clone()))
-            .collect();
-        let prev_frame_diff: BTreeMap<usize, Option<MachineValue>> = self
-            .prev_frame
-            .iter()
-            .filter(|(k, v)| {
-                if let Some(ref old_v) = old.prev_frame.get(k) {
-                    v != old_v
-                } else {
-                    true
-                }
-            })
-            .map(|(&k, v)| (k, Some(v.clone())))
-            .chain(
-                old.prev_frame
-                    .iter()
-                    .filter(|(k, _)| self.prev_frame.get(k).is_none())
-                    .map(|(&k, _)| (k, None)),
-            )
-            .collect();
-        let first_diff_wasm_stack_depth: usize = self
-            .wasm_stack
-            .iter()
-            .zip(old.wasm_stack.iter())
-            .enumerate()
-            .find(|&(_, (a, b))| a != b)
-            .map(|x| x.0)
-            .unwrap_or_else(|| old.wasm_stack.len().min(self.wasm_stack.len()));
-        MachineStateDiff {
-            last: None,
-            stack_push: self.stack_values[first_diff_stack_depth..].to_vec(),
-            stack_pop: old.stack_values.len() - first_diff_stack_depth,
-            reg_diff,
-
-            prev_frame_diff,
-
-            wasm_stack_push: self.wasm_stack[first_diff_wasm_stack_depth..].to_vec(),
-            wasm_stack_pop: old.wasm_stack.len() - first_diff_wasm_stack_depth,
-
-            wasm_inst_offset: self.wasm_inst_offset,
-        }
+impl Size {
+    pub fn bits(&self) -> u32 {
+        8 * self.bytes()
     }
-}
 
-impl MachineStateDiff {
-    /// Creates a `MachineState` from the given `&FunctionStateMap`.
-    pub fn _build_state(&self, m: &FunctionStateMap) -> MachineState {
-        let mut chain: Vec<&MachineStateDiff> = vec![self];
-        let mut current = self.last;
-        while let Some(x) = current {
-            let that = &m.diffs[x];
-            current = that.last;
-            chain.push(that);
-        }
-        chain.reverse();
-        let mut state = m.initial.clone();
-        for x in chain {
-            for _ in 0..x.stack_pop {
-                state.stack_values.pop().unwrap();
-            }
-            for v in &x.stack_push {
-                state.stack_values.push(v.clone());
-            }
-            for &(index, ref v) in &x.reg_diff {
-                state.register_values[index.0] = v.clone();
-            }
-            for (index, ref v) in &x.prev_frame_diff {
-                if let Some(ref x) = v {
-                    state.prev_frame.insert(*index, x.clone());
-                } else {
-                    state.prev_frame.remove(index).unwrap();
-                }
-            }
-            for _ in 0..x.wasm_stack_pop {
-                state.wasm_stack.pop().unwrap();
-            }
-            for v in &x.wasm_stack_push {
-                state.wasm_stack.push(*v);
-            }
+    pub fn bytes(&self) -> u32 {
+        match self {
+            Size::S8 => 1,
+            Size::S16 => 2,
+            Size::S32 => 4,
+            Size::S64 => 8,
         }
-        state.wasm_inst_offset = self.wasm_inst_offset;
-        state
     }
 }
diff --git a/lib/compiler-singlepass/src/compiler.rs b/lib/compiler-singlepass/src/compiler.rs
index 06f9cecf70..865c0f1324 100644
--- a/lib/compiler-singlepass/src/compiler.rs
+++ b/lib/compiler-singlepass/src/compiler.rs
@@ -3,7 +3,7 @@
 #![allow(unused_imports, dead_code)]
 
 use crate::codegen::FuncGen;
-use crate::config::Singlepass;
+use crate::config::{self, Singlepass};
 #[cfg(feature = "unwind")]
 use crate::dwarf::WriterRelocate;
 use crate::machine::Machine;
@@ -11,29 +11,38 @@ use crate::machine::{
     gen_import_call_trampoline, gen_std_dynamic_import_trampoline, gen_std_trampoline,
 };
 use crate::machine_arm64::MachineARM64;
+use crate::machine_riscv::MachineRiscv;
 use crate::machine_x64::MachineX86_64;
 #[cfg(feature = "unwind")]
-use crate::unwind::{create_systemv_cie, UnwindFrame};
+use crate::unwind::{UnwindFrame, create_systemv_cie};
 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::collections::HashMap;
 use std::sync::Arc;
+use wasmer_compiler::misc::{CompiledKind, save_assembly_to_file, types_to_signature};
+use wasmer_compiler::progress::ProgressContext;
 use wasmer_compiler::{
     Compiler, CompilerConfig, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader,
     ModuleMiddleware, ModuleMiddlewareChain, ModuleTranslationState,
+    types::{
+        function::{Compilation, CompiledFunction, FunctionBody, UnwindInfo},
+        module::CompileModuleInfo,
+        section::SectionIndex,
+    },
 };
 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,
+    CompilationProgressCallback, CompileError, FunctionIndex, FunctionType, LocalFunctionIndex,
+    MemoryIndex, ModuleInfo, TableIndex, TrapCode, TrapInformation, Type, VMOffsets,
 };
 
 /// A compiler that compiles a WebAssembly module with Singlepass.
 /// It does the compilation in one pass
+#[derive(Debug)]
 pub struct SinglepassCompiler {
     config: Singlepass,
 }
@@ -48,48 +57,50 @@ impl SinglepassCompiler {
     fn config(&self) -> &Singlepass {
         &self.config
     }
-}
-
-impl Compiler for SinglepassCompiler {
-    fn name(&self) -> &str {
-        "singlepass"
-    }
-
-    /// Get the middlewares for this compiler
-    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
-        &self.config.middlewares
-    }
 
-    /// Compile the module using Singlepass, producing a compilation result with
-    /// associated relocations.
-    fn compile_module(
+    fn compile_module_internal(
         &self,
         target: &Target,
         compile_info: &CompileModuleInfo,
-        _module_translation: &ModuleTranslationState,
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
     ) -> Result<Compilation, CompileError> {
-        match target.triple().architecture {
+        let arch = target.triple().architecture;
+        match arch {
             Architecture::X86_64 => {}
             Architecture::Aarch64(_) => {}
+            Architecture::Riscv64(_) => {}
             _ => {
                 return Err(CompileError::UnsupportedTarget(
                     target.triple().architecture.to_string(),
-                ))
+                ));
             }
-        }
+        };
 
         let calling_convention = match target.triple().default_calling_convention() {
             Ok(CallingConvention::WindowsFastcall) => CallingConvention::WindowsFastcall,
             Ok(CallingConvention::SystemV) => CallingConvention::SystemV,
             Ok(CallingConvention::AppleAarch64) => CallingConvention::AppleAarch64,
-            _ => {
-                return Err(CompileError::UnsupportedTarget(
-                    "Unsupported Calling convention for Singlepass compiler".to_string(),
-                ))
-            }
+            _ => match target.triple().architecture {
+                Architecture::Riscv64(_) => CallingConvention::SystemV,
+                _ => {
+                    return Err(CompileError::UnsupportedTarget(
+                        "Unsupported Calling convention for Singlepass compiler".to_string(),
+                    ));
+                }
+            },
         };
 
+        let module = &compile_info.module;
+        let total_functions = function_body_inputs.len() as u64;
+        let total_function_call_trampolines = module.signatures.len() as u64;
+        let total_dynamic_trampolines = module.num_imported_functions as u64;
+        let total_steps =
+            total_functions + total_function_call_trampolines + total_dynamic_trampolines;
+        let progress = progress_callback
+            .cloned()
+            .map(|cb| ProgressContext::new(cb, total_steps, "singlepass::functions"));
+
         // Generate the frametable
         #[cfg(feature = "unwind")]
         let dwarf_frametable = if function_body_inputs.is_empty() {
@@ -117,6 +128,7 @@ impl Compiler for SinglepassCompiler {
         let table_styles = &compile_info.table_styles;
         let vmoffsets = VMOffsets::new(8, &compile_info.module);
         let module = &compile_info.module;
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
         let mut custom_sections: PrimaryMap<SectionIndex, _> = (0..module.num_imported_functions)
             .map(FunctionIndex::new)
             .collect::<Vec<_>>()
@@ -133,6 +145,7 @@ impl Compiler for SinglepassCompiler {
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
             .collect();
+        #[cfg_attr(not(feature = "unwind"), allow(unused_variables))]
         let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
             .iter()
             .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
@@ -156,7 +169,7 @@ impl Compiler for SinglepassCompiler {
                     }
                 }
 
-                match target.triple().architecture {
+                let res = match arch {
                     Architecture::X86_64 => {
                         let machine = MachineX86_64::new(Some(target.clone()))?;
                         let mut generator = FuncGen::new(
@@ -176,7 +189,7 @@ impl Compiler for SinglepassCompiler {
                             generator.feed_operator(op)?;
                         }
 
-                        generator.finalize(input)
+                        generator.finalize(input, arch)
                     }
                     Architecture::Aarch64(_) => {
                         let machine = MachineARM64::new(Some(target.clone()));
@@ -197,21 +210,70 @@ impl Compiler for SinglepassCompiler {
                             generator.feed_operator(op)?;
                         }
 
-                        generator.finalize(input)
+                        generator.finalize(input, arch)
+                    }
+                    Architecture::Riscv64(_) => {
+                        let machine = MachineRiscv::new(Some(target.clone()))?;
+                        let mut generator = FuncGen::new(
+                            module,
+                            &self.config,
+                            &vmoffsets,
+                            memory_styles,
+                            table_styles,
+                            i,
+                            &locals,
+                            machine,
+                            calling_convention,
+                        )?;
+                        while generator.has_control_frames() {
+                            generator.set_srcloc(reader.original_position() as u32);
+                            let op = reader.read_operator()?;
+                            generator.feed_operator(op)?;
+                        }
+
+                        generator.finalize(input, arch)
                     }
                     _ => unimplemented!(),
+                }?;
+
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
                 }
+
+                Ok(res)
             })
             .collect::<Result<Vec<_>, CompileError>>()?
             .into_iter()
             .unzip();
 
+        let module_hash = module.hash_string();
         let function_call_trampolines = module
             .signatures
             .values()
             .collect::<Vec<_>>()
             .into_par_iter_if_rayon()
-            .map(|func_type| gen_std_trampoline(func_type, target, calling_convention))
+            .map(|func_type| -> Result<FunctionBody, CompileError> {
+                let body = gen_std_trampoline(func_type, target, calling_convention)?;
+                if let Some(callbacks) = self.config.callbacks.as_ref() {
+                    callbacks.obj_memory_buffer(
+                        &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+                        &module_hash,
+                        &body.body,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+                        &module_hash,
+                        arch,
+                        &body.body,
+                        HashMap::new(),
+                    )?;
+                }
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+
+                Ok(body)
+            })
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
             .collect::<PrimaryMap<_, _>>();
@@ -220,20 +282,41 @@ impl Compiler for SinglepassCompiler {
             .imported_function_types()
             .collect::<Vec<_>>()
             .into_par_iter_if_rayon()
-            .map(|func_type| {
-                gen_std_dynamic_import_trampoline(
+            .map(|func_type| -> Result<FunctionBody, CompileError> {
+                let body = gen_std_dynamic_import_trampoline(
                     &vmoffsets,
                     &func_type,
                     target,
                     calling_convention,
-                )
+                )?;
+                if let Some(callbacks) = self.config.callbacks.as_ref() {
+                    callbacks.obj_memory_buffer(
+                        &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+                        &module_hash,
+                        &body.body,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+                        &module_hash,
+                        arch,
+                        &body.body,
+                        HashMap::new(),
+                    )?;
+                }
+                if let Some(progress) = progress.as_ref() {
+                    progress.notify()?;
+                }
+                Ok(body)
             })
             .collect::<Result<Vec<_>, _>>()?
             .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,24 +324,80 @@ 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,
         })
     }
+}
+
+impl Compiler for SinglepassCompiler {
+    fn name(&self) -> &str {
+        "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
+    }
+
+    /// Compile the module using Singlepass, producing a compilation result with
+    /// associated relocations.
+    fn compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        _module_translation: &ModuleTranslationState,
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
+    ) -> Result<Compilation, CompileError> {
+        #[cfg(feature = "rayon")]
+        {
+            let num_threads = self.config.num_threads.get();
+            let pool = rayon::ThreadPoolBuilder::new()
+                .num_threads(num_threads)
+                .build()
+                .map_err(|e| {
+                    CompileError::Codegen(format!("failed to build rayon thread pool: {e}"))
+                })?;
+
+            pool.install(|| {
+                self.compile_module_internal(
+                    target,
+                    compile_info,
+                    function_body_inputs,
+                    progress_callback,
+                )
+            })
+        }
+
+        #[cfg(not(feature = "rayon"))]
+        {
+            self.compile_module_internal(
+                target,
+                compile_info,
+                function_body_inputs,
+                progress_callback,
+            )
+        }
+    }
 
     fn get_cpu_features_used(&self, cpu_features: &EnumSet<CpuFeature>) -> EnumSet<CpuFeature> {
         let used = CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1;
@@ -291,7 +430,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::{
+        MemoryStyle, TableStyle,
+        target::{CpuFeature, Triple},
+    };
 
     fn dummy_compilation_ingredients<'a>() -> (
         CompileModuleInfo,
@@ -316,19 +458,19 @@ mod tests {
         // Compile for 32bit Linux
         let linux32 = Target::new(triple!("i686-unknown-linux-gnu"), CpuFeature::for_host());
         let (info, translation, inputs) = dummy_compilation_ingredients();
-        let result = compiler.compile_module(&linux32, &info, &translation, inputs);
+        let result = compiler.compile_module(&linux32, &info, &translation, inputs, None);
         match result.unwrap_err() {
             CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"),
-            error => panic!("Unexpected error: {:?}", error),
+            error => panic!("Unexpected error: {error:?}"),
         };
 
         // Compile for win32
         let win32 = Target::new(triple!("i686-pc-windows-gnu"), CpuFeature::for_host());
         let (info, translation, inputs) = dummy_compilation_ingredients();
-        let result = compiler.compile_module(&win32, &info, &translation, inputs);
+        let result = compiler.compile_module(&win32, &info, &translation, inputs, None);
         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:?}"),
         };
     }
 
@@ -338,17 +480,23 @@ mod tests {
         let mut features =
             CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1;
         // simple test
-        assert!(compiler
-            .get_cpu_features_used(&features)
-            .is_subset(CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+        assert!(
+            compiler.get_cpu_features_used(&features).is_subset(
+                CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1
+            )
+        );
         // check that an AVX build don't work on SSE4.2 only host
-        assert!(!compiler
-            .get_cpu_features_used(&features)
-            .is_subset(CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+        assert!(
+            !compiler
+                .get_cpu_features_used(&features)
+                .is_subset(CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1)
+        );
         // check that having a host with AVX512 doesn't change anything
         features.insert_all(CpuFeature::AVX512DQ | CpuFeature::AVX512F);
-        assert!(compiler
-            .get_cpu_features_used(&features)
-            .is_subset(CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+        assert!(
+            compiler.get_cpu_features_used(&features).is_subset(
+                CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1
+            )
+        );
     }
 }
diff --git a/lib/compiler-singlepass/src/config.rs b/lib/compiler-singlepass/src/config.rs
index ea01ebb6de..1f4b2fd65f 100644
--- a/lib/compiler-singlepass/src/config.rs
+++ b/lib/compiler-singlepass/src/config.rs
@@ -1,16 +1,89 @@
 // Allow unused imports while developing
 #![allow(unused_imports, dead_code)]
 
-use crate::compiler::SinglepassCompiler;
-use std::sync::Arc;
-use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{CpuFeature, Features, Target};
+use crate::{compiler::SinglepassCompiler, machine::AssemblyComment};
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{self, Write},
+    num::NonZero,
+    path::PathBuf,
+    sync::Arc,
+};
+use target_lexicon::Architecture;
+use wasmer_compiler::{
+    Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware,
+    misc::{CompiledKind, function_kind_to_filename, save_assembly_to_file},
+};
+use wasmer_types::{
+    Features,
+    target::{CpuFeature, Target},
+};
+
+/// Callbacks to the different Cranelift compilation phases.
+#[derive(Debug, Clone)]
+pub struct SinglepassCallbacks {
+    debug_dir: PathBuf,
+}
+
+impl SinglepassCallbacks {
+    /// Creates a new instance of `SinglepassCallbacks` with the specified debug directory.
+    pub fn new(debug_dir: PathBuf) -> Result<Self, io::Error> {
+        // Create the debug dir in case it doesn't exist
+        std::fs::create_dir_all(&debug_dir)?;
+        Ok(Self { debug_dir })
+    }
+
+    fn base_path(&self, module_hash: &Option<String>) -> PathBuf {
+        let mut path = self.debug_dir.clone();
+        if let Some(hash) = module_hash {
+            path.push(hash);
+        }
+        std::fs::create_dir_all(&path)
+            .unwrap_or_else(|_| panic!("cannot create debug directory: {}", path.display()));
+        path
+    }
+
+    /// Writes the object file memory buffer to a debug file.
+    pub fn obj_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        mem_buffer: &[u8],
+    ) {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".o"));
+        let mut file =
+            File::create(path).expect("Error while creating debug file from Cranelift object");
+        file.write_all(mem_buffer).unwrap();
+    }
+
+    /// Writes the assembly memory buffer to a debug file.
+    pub fn asm_memory_buffer(
+        &self,
+        kind: &CompiledKind,
+        module_hash: &Option<String>,
+        arch: Architecture,
+        mem_buffer: &[u8],
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<(), wasmer_types::CompileError> {
+        let mut path = self.base_path(module_hash);
+        path.push(function_kind_to_filename(kind, ".s"));
+        save_assembly_to_file(arch, path, mem_buffer, assembly_comments)
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct Singlepass {
     pub(crate) enable_nan_canonicalization: bool,
+
     /// The middleware chain.
     pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+
+    pub(crate) callbacks: Option<SinglepassCallbacks>,
+
+    /// The number of threads to use for compilation.
+    pub num_threads: NonZero<usize>,
 }
 
 impl Singlepass {
@@ -20,6 +93,8 @@ impl Singlepass {
         Self {
             enable_nan_canonicalization: true,
             middlewares: vec![],
+            callbacks: None,
+            num_threads: std::thread::available_parallelism().unwrap_or(NonZero::new(1).unwrap()),
         }
     }
 
@@ -27,6 +102,19 @@ impl Singlepass {
         self.enable_nan_canonicalization = enable;
         self
     }
+
+    /// Callbacks that will triggered in the different compilation
+    /// phases in Singlepass.
+    pub fn callbacks(&mut self, callbacks: Option<SinglepassCallbacks>) -> &mut Self {
+        self.callbacks = callbacks;
+        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
+    }
 }
 
 impl CompilerConfig for Singlepass {
@@ -40,11 +128,9 @@ 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 {
-        let mut features = Features::default();
-        features.multi_value(false);
-        features
+    /// Gets the supported features for this compiler in the given target
+    fn supported_features_for_target(&self, _target: &Target) -> Features {
+        Features::default()
     }
 
     /// Pushes a middleware onto the back of the middleware chain.
diff --git a/lib/compiler-singlepass/src/dwarf.rs b/lib/compiler-singlepass/src/dwarf.rs
index 815787b468..30e8af7689 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::{
+    RunTimeEndian, SectionId,
+    write::{Address, EndianVec, Result, Writer},
 };
+use wasmer_compiler::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody},
+};
+use wasmer_types::{LocalFunctionIndex, entity::EntityRef, target::Endianness};
 
 #[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..9c9924341a 100644
--- a/lib/compiler-singlepass/src/emitter_arm64.rs
+++ b/lib/compiler-singlepass/src/emitter_arm64.rs
@@ -1,18 +1,23 @@
-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};
-use dynasm::dynasm;
+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,
+    machine_arm64::ARM64_RETURN_VALUE_REGISTERS,
+};
 pub use dynasmrt::aarch64::{encode_logical_immediate_32bit, encode_logical_immediate_64bit};
 use dynasmrt::{
-    aarch64::Aarch64Relocation, AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi,
-    VecAssembler,
+    AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi, VecAssembler,
+    aarch64::Aarch64Relocation,
+};
+use wasmer_compiler::types::{
+    function::FunctionBody,
+    section::{CustomSection, CustomSectionProtection, SectionBody},
 };
 use wasmer_types::{
-    CallingConvention, CompileError, CustomSection, CustomSectionProtection, FunctionBody,
-    FunctionIndex, FunctionType, SectionBody, Type, VMOffsets,
+    CompileError, FunctionIndex, FunctionType, Type, VMOffsets, target::CallingConvention,
 };
 
 type Assembler = VecAssembler<Aarch64Relocation>;
@@ -84,6 +89,7 @@ pub enum GPROrMemory {
     Memory(GPR, i32),
 }
 
+#[allow(unused)]
 pub trait EmitterARM64 {
     fn get_label(&mut self) -> Label;
     fn get_offset(&self) -> Offset;
@@ -231,7 +237,7 @@ pub trait EmitterARM64 {
         dst: Location,
     ) -> Result<(), CompileError>;
 
-    fn emit_cmp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) -> Result<(), CompileError>;
     fn emit_tst(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
 
     fn emit_lsl(
@@ -347,7 +353,7 @@ pub trait EmitterARM64 {
     fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError>;
     fn emit_b_label(&mut self, label: Label) -> Result<(), CompileError>;
     fn emit_cbz_label(&mut self, sz: Size, reg: Location, label: Label)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_cbnz_label(
         &mut self,
         sz: Size,
@@ -486,14 +492,6 @@ pub trait EmitterARM64 {
     fn emit_read_fpsr(&mut self, reg: GPR) -> Result<(), CompileError>;
     fn emit_write_fpsr(&mut self, reg: GPR) -> Result<(), CompileError>;
 
-    fn arch_supports_canonicalize_nan(&self) -> bool {
-        true
-    }
-
-    fn arch_requires_indirect_call_trampoline(&self) -> bool {
-        false
-    }
-
     fn arch_emit_indirect_call_with_trampoline(
         &mut self,
         _loc: Location,
@@ -519,62 +517,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));
+                assert!(disp.is_multiple_of(8) && (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));
+                assert!(disp.is_multiple_of(4) && (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));
+                assert!(disp.is_multiple_of(2) && (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));
+                assert!(disp.is_multiple_of(8) && (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));
+                assert!(disp.is_multiple_of(4) && (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 +567,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 +582,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 +611,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 +620,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 +639,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 +661,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 +692,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 +724,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 +743,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 +762,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 +783,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 +800,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 +810,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 +830,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 +850,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 +869,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 +884,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 +903,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 +918,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 +938,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 +958,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 +979,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 +991,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 +1000,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 +1015,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 +1033,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 +1048,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 +1058,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 +1120,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 +1132,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 +1141,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 +1151,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 +1191,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 +1245,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 +1293,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 +1317,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 +1363,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 +1394,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!(
@@ -1636,48 +1408,44 @@ impl EmitterARM64 for Assembler {
         Ok(())
     }
 
-    fn emit_cmp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
-        match (sz, src, dst) {
+    /// Emit a CMP instruction that compares `left` against `right`.
+    ///
+    /// Note: callers sometimes pass operands in the opposite order compared
+    /// to other binary operators. This function performs the comparison as
+    /// provided (i.e. it emits `cmp left, right` semantics).
+    fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) -> Result<(), CompileError> {
+        match (sz, left, right) {
             (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),
+            _ => codegen_error!("singlepass can't emit CMP {:?} {:?} {:?}", sz, left, right),
         }
         Ok(())
     }
@@ -1685,31 +1453,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,57 +1490,38 @@ 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;
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm > 63 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsl X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
                 if imm > 63 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsl X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm > 31 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsl W(dst), W(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;
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm > 31 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1804,57 +1546,38 @@ 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;
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; asr X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; asr X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; asr W(dst), W(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;
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1879,57 +1602,38 @@ 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;
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsr X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsr X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsr W(dst), W(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;
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1954,59 +1658,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 ; 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;
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 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);
                 }
                 dynasm!(self ; ror X(dst), X(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;
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
                 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);
                 }
                 dynasm!(self ; ror X(dst), X(src1), imm);
             }
-            (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;
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 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;
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; ror X(dst), X(src1), imm as u32);
             }
-            (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;
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -2032,33 +1717,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 +1757,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 +1797,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 +1838,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 +1857,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 +1876,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,19 +1900,13 @@ 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!(
-                "singlepass can't emit UDIV {:?} {:?} {:?} {:?}",
+                "singlepass can't emit SDIV {:?} {:?} {:?} {:?}",
                 sz,
                 src1,
                 src2,
@@ -2284,10 +1933,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 +1942,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 +1959,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 +1971,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 +1983,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 +1992,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 +2001,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 +2010,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 +2097,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 +2116,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 +2142,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 +2154,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 +2169,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 +2185,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 +2202,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 +2222,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 +2247,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 +2271,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 +2335,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 +2343,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 +2352,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 +2367,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 +2380,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 +2392,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 +2411,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 +2435,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 +2459,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 +2483,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 +2508,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 +2532,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 +2551,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 +2563,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 +2575,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 +2587,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 +2606,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 +2636,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 +2660,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 +2683,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 +2713,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 +2737,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 +2772,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,25 +2825,34 @@ 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
-    let mut stack_offset = stack_args as u32 * 8;
-    if stack_args > 0 {
-        if stack_offset % 16 != 0 {
+    let stack_return_slots = sig
+        .results()
+        .len()
+        .saturating_sub(ARM64_RETURN_VALUE_REGISTERS.len());
+    let mut stack_offset = (stack_args + stack_return_slots) as u32 * 8;
+    if stack_offset > 0 {
+        if !stack_offset.is_multiple_of(16) {
             stack_offset += 8;
-            assert!(stack_offset % 16 == 0);
+            assert!(stack_offset.is_multiple_of(16));
+        }
+        if stack_offset < 0x1000 {
+            dynasm!(a ; sub sp, sp, stack_offset);
+        } else {
+            a.emit_mov_imm(Location::GPR(GPR::X26), stack_offset as u64)?;
+            dynasm!(a ; sub sp, sp, x26);
         }
-        dynasm!(a ; sub sp, sp, stack_offset);
     }
 
     // Move arguments to their locations.
     // `callee_vmctx` is already in the first argument register, so no need to move.
-    let mut caller_stack_offset: i32 = 0;
+    let mut caller_stack_offset = stack_return_slots as u32 * 8;
     for (i, param) in sig.params().iter().enumerate() {
         let sz = match *param {
             Type::I32 | Type::F32 => Size::S32,
@@ -3368,17 +2876,8 @@ pub fn gen_std_trampoline_arm64(
                 #[allow(clippy::single_match)]
                 match calling_convention {
                     CallingConvention::AppleAarch64 => {
-                        let sz = 1
-                            << match sz {
-                                Size::S8 => 0,
-                                Size::S16 => 1,
-                                Size::S32 => 2,
-                                Size::S64 => 3,
-                            };
                         // align first
-                        if sz > 1 && caller_stack_offset & (sz - 1) != 0 {
-                            caller_stack_offset = (caller_stack_offset + (sz - 1)) & !(sz - 1);
-                        }
+                        caller_stack_offset = caller_stack_offset.next_multiple_of(sz.bytes());
                     }
                     _ => (),
                 };
@@ -3391,17 +2890,11 @@ pub fn gen_std_trampoline_arm64(
                 a.emit_str(
                     sz,
                     Location::GPR(GPR::X16),
-                    Location::Memory(GPR::XzrSp, caller_stack_offset),
+                    Location::Memory(GPR::XzrSp, caller_stack_offset as _),
                 )?;
                 match calling_convention {
                     CallingConvention::AppleAarch64 => {
-                        caller_stack_offset += 1
-                            << match sz {
-                                Size::S8 => 0,
-                                Size::S16 => 1,
-                                Size::S32 => 2,
-                                Size::S64 => 3,
-                            };
+                        caller_stack_offset += sz.bytes();
                     }
                     _ => {
                         caller_stack_offset += 8;
@@ -3411,20 +2904,43 @@ 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() {
-        a.emit_str(Size::S64, Location::GPR(GPR::X0), Location::Memory(args, 0))?;
+    // Write return values.
+    let mut n_stack_return_slots: usize = 0;
+    for i in 0..sig.results().len() {
+        let src = if let Some(&reg) = ARM64_RETURN_VALUE_REGISTERS.get(i) {
+            reg
+        } else {
+            let loc = GPR::X16;
+            a.emit_ldr(
+                Size::S64,
+                Location::GPR(GPR::X16),
+                Location::Memory(GPR::XzrSp, (n_stack_return_slots as u32 * 8) as _),
+            )?;
+            n_stack_return_slots += 1;
+            loc
+        };
+        a.emit_str(
+            Size::S64,
+            Location::GPR(src),
+            Location::Memory(args, (i * 16) as _),
+        )?;
     }
 
     // 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
     );
+    let restored_stack_offset = 32 + stack_offset;
+    if restored_stack_offset < 0x1000 {
+        dynasm!(a; add sp, sp, restored_stack_offset);
+    } else {
+        a.emit_mov_imm(Location::GPR(GPR::X26), restored_stack_offset as u64)?;
+        dynasm!(a; add sp, sp, x26);
+    }
+    dynasm!(a; ret);
 
     let mut body = a.finalize().unwrap();
     body.shrink_to_fit();
@@ -3478,7 +2994,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 => {
@@ -3486,9 +3002,7 @@ pub fn gen_std_dynamic_import_trampoline_arm64(
                         CallingConvention::AppleAarch64 => match *ty {
                             Type::I32 | Type::F32 => Size::S32,
                             _ => {
-                                if stack_param_count & 7 != 0 {
-                                    stack_param_count = (stack_param_count + 7) & !7;
-                                };
+                                stack_param_count = stack_param_count.next_multiple_of(8);
                                 Size::S64
                             }
                         },
@@ -3612,17 +3126,13 @@ pub fn gen_import_call_trampoline_arm64(
         match calling_convention {
             _ => {
                 // Allocate stack space for arguments.
-                let stack_offset: i32 = if sig.params().len() > 7 {
+                let mut stack_offset: u32 = if sig.params().len() > 7 {
                     7 * 8
                 } else {
-                    (sig.params().len() as i32) * 8
+                    (sig.params().len() as u32) * 8
                 };
-                let stack_offset = if stack_offset & 15 != 0 {
-                    stack_offset + 8
-                } else {
-                    stack_offset
-                };
-                if stack_offset > 0 {
+                stack_offset = stack_offset.next_multiple_of(16);
+                if stack_offset != 0 {
                     if stack_offset < 0x1000 {
                         a.emit_sub(
                             Size::S64,
@@ -3652,27 +3162,27 @@ pub fn gen_import_call_trampoline_arm64(
                     GPR::X7,
                 ];
                 let mut param_locations = vec![];
-                /* Clippy is wrong about using `i` to index `PARAM_REGS` here. */
-                #[allow(clippy::needless_range_loop)]
-                for i in 0..sig.params().len() {
+                for (i, param_reg) in PARAM_REGS.iter().enumerate().take(sig.params().len()) {
                     let loc = match i {
                         0..=6 => {
                             let loc = Location::Memory(GPR::XzrSp, (i * 8) as i32);
-                            a.emit_str(Size::S64, Location::GPR(PARAM_REGS[i]), loc)?;
+                            a.emit_str(Size::S64, Location::GPR(*param_reg), loc)?;
                             loc
                         }
-                        _ => Location::Memory(GPR::XzrSp, stack_offset + ((i - 7) * 8) as i32),
+                        _ => {
+                            Location::Memory(GPR::XzrSp, (stack_offset + (i as u32 - 7) * 8) as i32)
+                        }
                     };
                     param_locations.push(loc);
                 }
 
                 // Copy arguments.
-                let mut caller_stack_offset: i32 = 0;
+                let mut caller_stack_offset: u32 = 0;
                 let mut argalloc = ArgumentRegisterAllocator::default();
                 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 => {
@@ -3681,7 +3191,10 @@ pub fn gen_import_call_trampoline_arm64(
                             a.emit_str(
                                 Size::S64,
                                 Location::GPR(GPR::X16),
-                                Location::Memory(GPR::XzrSp, stack_offset + caller_stack_offset),
+                                Location::Memory(
+                                    GPR::XzrSp,
+                                    (stack_offset + caller_stack_offset) as i32,
+                                ),
                             )?;
                             caller_stack_offset += 8;
                             continue;
@@ -3720,7 +3233,7 @@ pub fn gen_import_call_trampoline_arm64(
     // for ldr, offset needs to be a multiple of 8, wich often is not
     // so use ldur, but then offset is limited to -255 .. +255. It will be positive here
     let offset =
-        if (offset > 0 && offset < 0xF8) || (offset > 0 && offset < 0x7FF8 && (offset & 7) == 0) {
+        if (offset > 0) && ((offset < 0xF8) || (offset < 0x7FF8 && offset.is_multiple_of(8))) {
             offset
         } else {
             a.emit_mov_imm(Location::GPR(GPR::X16), (offset as i64) as u64)?;
@@ -3735,7 +3248,7 @@ pub fn gen_import_call_trampoline_arm64(
     #[allow(clippy::match_single_binding)]
     match calling_convention {
         _ => {
-            if (offset & 7) == 0 {
+            if offset.is_multiple_of(8) {
                 a.emit_ldr(
                     Size::S64,
                     Location::GPR(GPR::X16),
@@ -3770,6 +3283,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_riscv.rs b/lib/compiler-singlepass/src/emitter_riscv.rs
new file mode 100644
index 0000000000..68578b3b72
--- /dev/null
+++ b/lib/compiler-singlepass/src/emitter_riscv.rs
@@ -0,0 +1,2166 @@
+//! RISC-V emitter scaffolding.
+
+use crate::{
+    codegen_error,
+    common_decl::Size,
+    location::{Location as AbstractLocation, Reg},
+    machine::MaybeImmediate,
+    machine_riscv::{ImmType, RISCV_RETURN_VALUE_REGISTERS},
+    riscv_decl::{ArgumentRegisterAllocator, RiscvRegister},
+};
+pub use crate::{
+    machine::{Label, Offset},
+    riscv_decl::{FPR, GPR},
+};
+use dynasmrt::{DynasmApi, DynasmLabelApi, VecAssembler, riscv::RiscvRelocation};
+use wasmer_compiler::types::{
+    function::FunctionBody,
+    section::{CustomSection, CustomSectionProtection, SectionBody},
+};
+use wasmer_types::{
+    CompileError, FunctionIndex, FunctionType, Type, VMOffsets,
+    target::{CallingConvention, CpuFeature},
+};
+
+type Assembler = VecAssembler<RiscvRelocation>;
+
+/// Force `dynasm!` to use the correct arch (riscv64) when cross-compiling.
+macro_rules! dynasm {
+    ($a:expr ; $($tt:tt)*) => {
+        dynasm::dynasm!(
+            $a
+            ; .arch riscv64
+            ; .feature g
+            ; $($tt)*
+        )
+    };
+}
+
+/// Location abstraction specialized to RISC-V.
+pub type Location = AbstractLocation<GPR, FPR>;
+
+/// Branch conditions for RISC-V.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Condition {
+    /// Signed less than
+    Lt,
+    /// Signed less than or equal
+    Le,
+    /// Signed greater than
+    Gt,
+    /// Signed greater than or equal
+    Ge,
+    /// Signed equal
+    Eq,
+    /// Signed not equal
+    Ne,
+
+    /// Unsigned less than
+    Ltu,
+    /// Unsigned less than or equal
+    Leu,
+    /// Unsigned greater than
+    Gtu,
+    /// Unsigned greater than or equal
+    Geu,
+}
+
+/// Floating-point number rounding mode
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum RoundingMode {
+    /// Round to Nearest, ties to Even (default)
+    Rne,
+    /// Round towards Zero
+    Rtz,
+    /// Round Down (towards -∞)
+    Rdn,
+    /// Round Up (towards +∞)
+    Rup,
+}
+
+/// Atomic binary operation type
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum AtomicBinaryOp {
+    Add,
+    Sub,
+    Or,
+    And,
+    Xor,
+    Exchange,
+}
+
+/// Scratch register used in function call trampolines.
+const SCRATCH_REG: GPR = GPR::X28;
+
+/// Emitter trait for RISC-V.
+#[allow(unused)]
+pub trait EmitterRiscv {
+    fn emit_jmp_on_condition(
+        &mut self,
+        cond: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_reserved_sd(
+        &mut self,
+        size: Size,
+        dest: GPR,
+        addr: GPR,
+        source: GPR,
+    ) -> Result<(), CompileError>;
+    /// Returns the SIMD (FPU) feature if available.
+    fn get_simd_arch(&self) -> Option<&CpuFeature>;
+    /// Generates a new internal label.
+    fn get_label(&mut self) -> Label;
+    /// Gets the current code offset.
+    fn get_offset(&self) -> Offset;
+    /// Returns the size of a jump instruction in bytes.
+    fn get_jmp_instr_size(&self) -> u8;
+
+    /// Finalize the function, e.g., resolve labels.
+    fn finalize_function(&mut self) -> Result<(), CompileError>;
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_brk(&mut self) -> Result<(), CompileError>;
+    fn emit_ld(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        reg: Location,
+        addr: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_sd(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError>;
+    fn emit_push(&mut self, size: Size, src: Location) -> Result<(), CompileError>;
+    fn emit_pop(&mut self, size: Size, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_add(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_mul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_udiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_srem(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_urem(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_and(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_or(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_xor(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sll(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_srl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sra(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_extend(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_not(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_neg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_ret(&mut self) -> Result<(), CompileError>;
+
+    fn emit_udf(&mut self, payload: u8) -> Result<(), CompileError>;
+
+    fn emit_mov_imm(&mut self, dst: Location, val: i64) -> Result<(), CompileError>;
+
+    // Floating-point type instructions
+    fn emit_fneg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_fmin(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fmax(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fsqrt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_fcvt(
+        &mut self,
+        signed: bool,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fcvt_with_rounding(
+        &mut self,
+        rounding: RoundingMode,
+        size: Size,
+        src: Location,
+        dst: Location,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_swap_fscr(&mut self, reg: GPR) -> Result<(), CompileError>;
+
+    // Control-flow related instructions
+    fn emit_cmp(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fcmp(
+        &mut self,
+        c: Condition,
+        size: Size,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_on_false_label(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_on_false_label_far(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_on_true_label_far(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_on_true_label(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError>;
+
+    fn emit_j_label(&mut self, label: Label, reg: Option<GPR>) -> Result<(), CompileError>;
+    fn emit_j_register(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError>;
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError>;
+
+    fn emit_rwfence(&mut self) -> Result<(), CompileError>;
+    fn emit_atomic_binop(
+        &mut self,
+        op: AtomicBinaryOp,
+        size: Size,
+        dest: GPR,
+        addr: GPR,
+        source: GPR,
+    ) -> Result<(), CompileError>;
+    fn emit_reserved_ld(&mut self, size: Size, reg: GPR, addr: GPR) -> Result<(), CompileError>;
+}
+
+impl EmitterRiscv for Assembler {
+    fn get_simd_arch(&self) -> Option<&CpuFeature> {
+        todo!()
+    }
+
+    fn get_label(&mut self) -> Label {
+        self.new_dynamic_label()
+    }
+
+    fn get_offset(&self) -> Offset {
+        self.offset()
+    }
+
+    fn get_jmp_instr_size(&self) -> u8 {
+        todo!()
+    }
+
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        Ok(())
+    }
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; => label);
+        Ok(())
+    }
+
+    fn emit_brk(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; ebreak);
+        Ok(())
+    }
+
+    fn emit_udf(&mut self, payload: u8) -> Result<(), CompileError> {
+        dynasm!(self
+            ; li.12 a0, payload as _
+            ; unimp);
+        Ok(())
+    }
+
+    fn emit_ld(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        reg: Location,
+        addr: Location,
+    ) -> Result<(), CompileError> {
+        let Location::Memory(addr, disp) = addr else {
+            codegen_error!("singlepass can't emit LD {:?}, {:?}, {:?}", sz, reg, addr);
+        };
+        assert!(ImmType::Bits12.compatible_imm(disp as i64));
+
+        match (sz, signed, reg) {
+            (Size::S64, _, Location::GPR(reg)) => {
+                dynasm!(self ; ld X(reg), [X(addr), disp]);
+            }
+            (Size::S32, false, Location::GPR(reg)) => {
+                dynasm!(self ; lwu X(reg), [X(addr), disp]);
+            }
+            (Size::S32, true, Location::GPR(reg)) => {
+                dynasm!(self ; lw X(reg), [X(addr), disp]);
+            }
+            (Size::S16, false, Location::GPR(reg)) => {
+                dynasm!(self ; lhu X(reg), [X(addr), disp]);
+            }
+            (Size::S16, true, Location::GPR(reg)) => {
+                dynasm!(self ; lh X(reg), [X(addr), disp]);
+            }
+            (Size::S8, false, Location::GPR(reg)) => {
+                dynasm!(self ; lbu X(reg), [X(addr), disp]);
+            }
+            (Size::S8, true, Location::GPR(reg)) => {
+                dynasm!(self ; lb X(reg), [X(addr), disp]);
+            }
+            (Size::S64, _, Location::SIMD(reg)) => {
+                dynasm!(self ; fld F(reg), [X(addr), disp]);
+            }
+            (Size::S32, _, Location::SIMD(reg)) => {
+                dynasm!(self ; flw F(reg), [X(addr), disp]);
+            }
+            _ => codegen_error!("singlepass can't emit LD {:?}, {:?}, {:?}", sz, reg, addr),
+        }
+        Ok(())
+    }
+
+    fn emit_sd(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError> {
+        let Location::Memory(addr, disp) = addr else {
+            codegen_error!("singlepass can't emit SD {:?}, {:?}, {:?}", sz, reg, addr);
+        };
+        assert!(ImmType::Bits12.compatible_imm(disp as i64));
+
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                dynasm!(self ; sd X(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::GPR(reg)) => {
+                dynasm!(self ; sw X(reg), [X(addr), disp]);
+            }
+            (Size::S16, Location::GPR(reg)) => {
+                dynasm!(self ; sh X(reg), [X(addr), disp]);
+            }
+            (Size::S8, Location::GPR(reg)) => {
+                dynasm!(self ; sb X(reg), [X(addr), disp]);
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                dynasm!(self ; fsd F(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::SIMD(reg)) => {
+                dynasm!(self ; fsw F(reg), [X(addr), disp]);
+            }
+            _ => codegen_error!("singlepass can't emit SD {:?}, {:?}, {:?}", sz, reg, addr),
+        }
+        Ok(())
+    }
+
+    fn emit_push(&mut self, size: Size, src: Location) -> Result<(), CompileError> {
+        match (size, src) {
+            (Size::S64, Location::GPR(_)) => {
+                self.emit_sub(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::Imm64(8),
+                    Location::GPR(GPR::Sp),
+                )?;
+                self.emit_sd(Size::S64, src, Location::Memory(GPR::Sp, 0))?;
+            }
+            _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", size, src),
+        }
+        Ok(())
+    }
+
+    fn emit_pop(&mut self, size: Size, dst: Location) -> Result<(), CompileError> {
+        match (size, dst) {
+            (Size::S64, Location::GPR(_)) => {
+                self.emit_ld(Size::S64, false, dst, Location::Memory(GPR::Sp, 0))?;
+                self.emit_add(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::Imm64(8),
+                    Location::GPR(GPR::Sp),
+                )?;
+            }
+            _ => codegen_error!("singlepass can't emit POP {:?} {:?}", size, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_add(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; add X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12.compatible_imm(imm as i64));
+                dynasm!(self ; addi X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; addw X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12.compatible_imm(imm as i64));
+                dynasm!(self ; addiw X(dst), X(src1), imm as _);
+            }
+
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fadd.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fadd.d F(dst), F(src1), F(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit ADD {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_sub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; sub X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; addi X(dst), X(src1), -(imm as i32) as _);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; addi X(dst), X(src1), -(imm as i32) as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; subw X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; addiw X(dst), X(src1), -(imm as i32) as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; addiw X(dst), X(src1), -(imm as i32) as _);
+            }
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fsub.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fsub.d F(dst), F(src1), F(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SUB {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_mul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; mul X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; mulw X(dst), X(src1), X(src2));
+            }
+
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmul.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmul.d F(dst), F(src1), F(src2));
+            }
+
+            _ => codegen_error!(
+                "singlepass can't emit MUL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_udiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; divuw X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; divu X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_sdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; divw X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; div X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_urem(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; remuw X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; remu X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UREM {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_srem(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; remw X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; rem X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit REM {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_and(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (
+                Size::S32 | Size::S64,
+                Location::GPR(src1),
+                Location::GPR(src2),
+                Location::GPR(dst),
+            ) => {
+                dynasm!(self ; and X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; andi X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; andi X(dst), X(src1), imm as _);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit AND {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_or(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (
+                Size::S32 | Size::S64,
+                Location::GPR(src1),
+                Location::GPR(src2),
+                Location::GPR(dst),
+            ) => {
+                dynasm!(self ; or X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; ori X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; ori X(dst), X(src1), imm as _);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit OR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_xor(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (
+                Size::S32 | Size::S64,
+                Location::GPR(src1),
+                Location::GPR(src2),
+                Location::GPR(dst),
+            ) => {
+                dynasm!(self ; xor X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; xori X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                assert!(ImmType::Bits12Subtraction.compatible_imm(imm as i64));
+                dynasm!(self ; xori X(dst), X(src1), imm as _);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit XOR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_sll(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; sll X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SLL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; slli X(dst), X(src1), imm as _);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SLL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; slli X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; sllw X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u32::BITS {
+                    codegen_error!("singlepass SLL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; slliw X(dst), X(src1), imm as _);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SLL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_srl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; srl X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SRL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srli X(dst), X(src1), imm as _);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SRL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srli X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; srlw X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u32::BITS {
+                    codegen_error!("singlepass SRL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srliw X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                if imm >= u32::BITS as _ {
+                    codegen_error!("singlepass SRL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srliw X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::Imm32(imm), Location::GPR(src2), Location::GPR(dst)) => {
+                self.emit_mov_imm(Location::GPR(dst), imm as i64)?;
+                dynasm!(self ; srlw X(dst), X(dst), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SRL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_sra(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; sra X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SRA with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srai X(dst), X(src1), imm as _);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u64::BITS as _ {
+                    codegen_error!("singlepass SRA with incompatible imm {}", imm);
+                }
+                dynasm!(self ; srai X(dst), X(src1), imm as _);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                dynasm!(self ; sraw X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                if imm >= u32::BITS {
+                    codegen_error!("singlepass SRA with incompatible imm {}", imm);
+                }
+                dynasm!(self ; sraiw X(dst), X(src1), imm as _);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SRA {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_extend(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        let bit_shift = match sz {
+            Size::S8 => 56,
+            Size::S16 => 48,
+            Size::S32 => 32,
+            _ => codegen_error!("singlepass can't emit SEXT {:?} {:?} {:?}", sz, src, dst),
+        };
+
+        match (signed, src, dst) {
+            (true, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self
+                    ; slli X(dst), X(src), bit_shift
+                    ; srai X(dst), X(dst), bit_shift
+                );
+            }
+            (false, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self
+                    ; slli X(dst), X(src), bit_shift
+                    ; srli X(dst), X(dst), bit_shift
+                );
+            }
+            _ => codegen_error!("singlepass can't emit SEXT {:?} {:?} {:?}", sz, src, dst),
+        };
+        Ok(())
+    }
+
+    fn emit_not(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; not X(dst), X(src));
+            }
+            _ => codegen_error!("singlepass can't emit NOT {:?} {:?} {:?}", sz, src, dst),
+        }
+
+        Ok(())
+    }
+
+    fn emit_neg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; neg X(dst), X(src));
+            }
+            _ => codegen_error!("singlepass can't emit NEG {:?} {:?} {:?}", sz, src, dst),
+        }
+
+        Ok(())
+    }
+
+    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)) => {
+                dynasm!(self ; mv X(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self
+                    ; slli X(dst), X(src), 32
+                    ; srli X(dst), X(dst), 32
+                );
+            }
+            (Size::S64, Location::GPR(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fmv.d.x F(dst), X(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::GPR(dst)) => {
+                dynasm!(self ; fmv.x.d X(dst), F(src));
+            }
+            (Size::S32, Location::GPR(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fmv.s.x F(dst), X(src));
+            }
+            (Size::S32, Location::SIMD(src), Location::GPR(dst)) => {
+                dynasm!(self ; fmv.x.s X(dst), F(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fmv.d F(dst), F(src));
+            }
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fmv.s F(dst), F(src));
+            }
+            _ => codegen_error!("singlepass can't emit MOV {:?} {:?} {:?}", sz, src, dst),
+        }
+
+        Ok(())
+    }
+
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; ret);
+        Ok(())
+    }
+
+    fn emit_mov_imm(&mut self, dst: Location, val: i64) -> Result<(), CompileError> {
+        // The number of used bits by the number including the sign bit.
+        // i64::MIN.abs() will overflow, thus handle it specially.
+        let used_bits = if val == i64::MIN {
+            i64::BITS
+        } else {
+            i64::BITS - val.abs().leading_zeros() + 1
+        };
+
+        match dst {
+            Location::GPR(dst) => match used_bits {
+                0..=12 => dynasm!(self ; li.12 X(dst), val as _),
+                13..=32 => dynasm!(self ; li.32 X(dst), val as _),
+                33..=43 => dynasm!(self ; li.43 X(dst), val),
+                44..=54 => dynasm!(self ; li.54 X(dst), val),
+                55..=64 => dynasm!(self ; li X(dst), val),
+                _ => unreachable!(),
+            },
+            _ => codegen_error!("singlepass can't emit MOVIMM {:?}", dst),
+        }
+        Ok(())
+    }
+
+    fn emit_fneg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fneg.d F(dst), F(src));
+            }
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fneg.s F(dst), F(src));
+            }
+            _ => codegen_error!("singlepass can't emit FNEG {:?} {:?} {:?}", sz, src, dst),
+        }
+
+        Ok(())
+    }
+
+    fn emit_fmin(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmin.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmin.d F(dst), F(src1), F(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FMIN {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_fmax(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmax.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fmax.d F(dst), F(src1), F(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FMAX {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_fdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fdiv.s F(dst), F(src1), F(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                dynasm!(self ; fdiv.d F(dst), F(src1), F(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    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)) => {
+                dynasm!(self ; fsqrt.s F(dst), F(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                dynasm!(self ; fsqrt.d F(dst), F(src));
+            }
+            _ => codegen_error!("singlepass can't emit FSQRT {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_fcvt(
+        &mut self,
+        signed: bool,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (signed, sz_in, src, sz_out, dst) {
+            // floating-point -> floating-point types
+            (_, Size::S32, Location::SIMD(src), Size::S64, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.d.s F(dst), F(src));
+            }
+            (_, Size::S64, Location::SIMD(src), Size::S32, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.s.d F(dst), F(src));
+            }
+            // floating-point -> int types
+            (true, Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.w.s X(dst), F(src), rtz);
+            }
+            (true, Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.w.d X(dst), F(src), rtz);
+            }
+            (true, Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.l.s X(dst), F(src), rtz);
+            }
+            (true, Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.l.d X(dst), F(src), rtz);
+            }
+            (false, Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.wu.s X(dst), F(src), rtz);
+            }
+            (false, Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.wu.d X(dst), F(src), rtz);
+            }
+            (false, Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.lu.s X(dst), F(src), rtz);
+            }
+            (false, Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; fcvt.lu.d X(dst), F(src), rtz);
+            }
+            // int -> floating-point types
+            (true, Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.s.w F(dst), X(src));
+            }
+            (true, Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.s.l F(dst), X(src));
+            }
+            (true, Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.d.w F(dst), X(src));
+            }
+            (true, Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.d.l F(dst), X(src));
+            }
+
+            (false, Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.s.wu F(dst), X(src));
+            }
+            (false, Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.s.lu F(dst), X(src));
+            }
+            (false, Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.d.wu F(dst), X(src));
+            }
+            (false, Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                dynasm!(self ; fcvt.d.lu F(dst), X(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FCVT {:?} {:?} {:?} {:?}",
+                sz_in,
+                src,
+                sz_out,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_fcvt_with_rounding(
+        &mut self,
+        rounding: RoundingMode,
+        size: Size,
+        src: Location,
+        dst: Location,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        let (Location::SIMD(src), Location::SIMD(dst)) = (src, dst) else {
+            codegen_error!(
+                "singlepass can't emit FCVT with rounding for non-register operands: {:?} {:?} {:?} {:?}",
+                src,
+                dst,
+                size,
+                rounding
+            )
+        };
+
+        match (size, rounding) {
+            (Size::S32, RoundingMode::Rne) => {
+                dynasm!(self
+                    ; fcvt.w.s X(tmp), F(src), rne
+                    ; fcvt.s.w F(dst), X(tmp), rne
+                    ; fsgnj.s F(dst), F(dst), F(src));
+            }
+            (Size::S32, RoundingMode::Rtz) => {
+                dynasm!(self
+                    ; fcvt.w.s X(tmp), F(src), rtz
+                    ; fcvt.s.w F(dst), X(tmp), rtz
+                    ; fsgnj.s F(dst), F(dst), F(src));
+            }
+            (Size::S32, RoundingMode::Rdn) => {
+                dynasm!(self
+                    ; fcvt.w.s X(tmp), F(src), rdn
+                    ; fcvt.s.w F(dst), X(tmp), rdn
+                    ; fsgnj.s F(dst), F(dst), F(src));
+            }
+            (Size::S32, RoundingMode::Rup) => {
+                dynasm!(self
+                    ; fcvt.w.s X(tmp), F(src), rup
+                    ; fcvt.s.w F(dst), X(tmp), rup
+                    ; fsgnj.s F(dst), F(dst), F(src));
+            }
+
+            (Size::S64, RoundingMode::Rne) => {
+                dynasm!(self
+                    ; fcvt.l.d X(tmp), F(src), rne
+                    ; fcvt.d.l F(dst), X(tmp), rne
+                    ; fsgnj.d F(dst), F(dst), F(src));
+            }
+            (Size::S64, RoundingMode::Rtz) => {
+                dynasm!(self
+                    ; fcvt.l.d X(tmp), F(src), rtz
+                    ; fcvt.d.l F(dst), X(tmp), rtz
+                    ; fsgnj.d F(dst), F(dst), F(src));
+            }
+            (Size::S64, RoundingMode::Rdn) => {
+                dynasm!(self
+                    ; fcvt.l.d X(tmp), F(src), rdn
+                    ; fcvt.d.l F(dst), X(tmp), rdn
+                    ; fsgnj.d F(dst), F(dst), F(src));
+            }
+            (Size::S64, RoundingMode::Rup) => {
+                dynasm!(self
+                    ; fcvt.l.d X(tmp), F(src), rup
+                    ; fcvt.d.l F(dst), X(tmp), rup
+                    ; fsgnj.d F(dst), F(dst), F(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FCVT with rounding {:?} {:?}",
+                size,
+                rounding
+            ),
+        }
+
+        Ok(())
+    }
+
+    // Swap `source` register with FSCR.
+    fn emit_swap_fscr(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; fscsr X(reg), X(reg));
+        Ok(())
+    }
+
+    fn emit_cmp(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let (Location::GPR(loc_a), Location::GPR(loc_b), Location::GPR(ret)) = (loc_a, loc_b, ret)
+        else {
+            codegen_error!(
+                "singlepass can't emit CMP {:?} {:?} {:?}",
+                loc_a,
+                loc_b,
+                ret
+            );
+        };
+
+        match c {
+            // signed comparison operations
+            Condition::Lt => {
+                dynasm!(self; slt X(ret), X(loc_a), X(loc_b));
+            }
+            Condition::Le => {
+                dynasm!(self
+                    ; slt X(ret), X(loc_b), X(loc_a)
+                    ; xori X(ret), X(ret), 1);
+            }
+            Condition::Gt => {
+                dynasm!(self; slt X(ret), X(loc_b), X(loc_a));
+            }
+            Condition::Ge => {
+                dynasm!(self
+                    ; slt X(ret), X(loc_a), X(loc_b)
+                    ; xori X(ret), X(ret), 1);
+            }
+            Condition::Eq => {
+                dynasm!(self
+                    ; xor X(ret), X(loc_a), X(loc_b)
+                    ; seqz X(ret), X(ret));
+            }
+            Condition::Ne => {
+                dynasm!(self
+                    ; xor X(ret), X(loc_a), X(loc_b)
+                    ; snez X(ret), X(ret));
+            }
+            // unsigned comparison operations
+            Condition::Ltu => {
+                dynasm!(self; sltu X(ret), X(loc_a), X(loc_b));
+            }
+            Condition::Leu => {
+                dynasm!(self
+                    ; sltu X(ret), X(loc_b), X(loc_a)
+                    ; xori X(ret), X(ret), 1);
+            }
+            Condition::Gtu => {
+                dynasm!(self; sltu X(ret), X(loc_b), X(loc_a));
+            }
+            Condition::Geu => {
+                dynasm!(self
+                    ; sltu X(ret), X(loc_a), X(loc_b)
+                    ; xori X(ret), X(ret), 1);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn emit_fcmp(
+        &mut self,
+        c: Condition,
+        size: Size,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let (Location::SIMD(loc_a), Location::SIMD(loc_b), Location::GPR(ret)) =
+            (loc_a, loc_b, ret)
+        else {
+            codegen_error!(
+                "singlepass can't emit FCMP {:?} {:?} {:?}",
+                loc_a,
+                loc_b,
+                ret
+            );
+        };
+
+        match (size, c) {
+            (Size::S32, Condition::Lt) => {
+                dynasm!(self ; flt.s X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S32, Condition::Le) => {
+                dynasm!(self ; fle.s X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S32, Condition::Gt) => {
+                dynasm!(self ; flt.s X(ret), F(loc_b), F(loc_a));
+            }
+            (Size::S32, Condition::Ge) => {
+                dynasm!(self ; fle.s X(ret), F(loc_b), F(loc_a));
+            }
+            (Size::S32, Condition::Eq) => {
+                dynasm!(self ; feq.s X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S32, Condition::Ne) => {
+                dynasm!(self
+                    ; feq.s X(ret), F(loc_a), F(loc_b)
+                    ; xori X(ret), X(ret), 1);
+            }
+
+            (Size::S64, Condition::Lt) => {
+                dynasm!(self ; flt.d X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S64, Condition::Le) => {
+                dynasm!(self ; fle.d X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S64, Condition::Gt) => {
+                dynasm!(self ; flt.d X(ret), F(loc_b), F(loc_a));
+            }
+            (Size::S64, Condition::Ge) => {
+                dynasm!(self; fle.d X(ret), F(loc_b), F(loc_a));
+            }
+            (Size::S64, Condition::Eq) => {
+                dynasm!(self ; feq.d X(ret), F(loc_a), F(loc_b));
+            }
+            (Size::S64, Condition::Ne) => {
+                dynasm!(self
+                    ; feq.d X(ret), F(loc_a), F(loc_b)
+                    ; xori X(ret), X(ret), 1);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FCMP {:?} {:?} {:?}",
+                loc_a,
+                loc_b,
+                ret
+            ),
+        }
+
+        Ok(())
+    }
+
+    fn emit_jmp_on_condition(
+        &mut self,
+        cond: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        let (Location::GPR(loc_a), Location::GPR(loc_b)) = (loc_a, loc_b) else {
+            codegen_error!("singlepass can't emit JMP_ON_COND {:?} {:?} ", loc_a, loc_b,);
+        };
+
+        let jump: Label = self.get_label();
+        let cont: Label = self.get_label();
+
+        match cond {
+            Condition::Eq => {
+                dynasm!(self; beq X(loc_a), X(loc_b), => jump);
+            }
+            Condition::Ne => {
+                dynasm!(self; bne X(loc_a), X(loc_b), => jump);
+            }
+            Condition::Ltu => {
+                dynasm!(self; bltu X(loc_a), X(loc_b), => jump);
+            }
+            Condition::Leu => {
+                dynasm!(self; bleu X(loc_a), X(loc_b), => jump);
+            }
+            Condition::Gtu => {
+                dynasm!(self; bgtu X(loc_a), X(loc_b), => jump);
+            }
+            Condition::Geu => {
+                dynasm!(self; bgeu X(loc_a), X(loc_b), => jump);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit jump on conditional branch {:?}",
+                cond
+            ),
+        }
+
+        self.emit_j_label(cont, Some(tmp))?;
+        self.emit_label(jump)?;
+        self.emit_j_label(label, Some(tmp))?;
+
+        self.emit_label(cont)?;
+
+        Ok(())
+    }
+
+    fn emit_on_false_label(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        match cond {
+            Location::GPR(cond) => {
+                dynasm!(self; beqz X(cond), => label);
+            }
+            _ if cond.is_imm() => {
+                let imm = cond.imm_value_scalar().unwrap();
+                if imm == 0 {
+                    return self.emit_j_label(label, Some(tmp));
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+        Ok(())
+    }
+    fn emit_on_false_label_far(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        let cont: Label = self.get_label();
+        match cond {
+            Location::GPR(cond) => {
+                // Use the negative condition to jump after the "j" instruction that will
+                // go to the requsted `label`.
+                dynasm!(self; bnez X(cond), => cont);
+            }
+            _ if cond.is_imm() => {
+                let imm = cond.imm_value_scalar().unwrap();
+                if imm == 0 {
+                    return self.emit_j_label(label, Some(tmp));
+                } else {
+                    self.emit_j_label(cont, Some(tmp))?;
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+
+        self.emit_j_label(label, Some(tmp))?;
+        self.emit_label(cont)?;
+        Ok(())
+    }
+    fn emit_on_true_label(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        match cond {
+            Location::GPR(cond) => {
+                dynasm!(self; bnez X(cond), => label);
+            }
+            _ if cond.is_imm() => {
+                let imm = cond.imm_value_scalar().unwrap();
+                if imm != 0 {
+                    return self.emit_j_label(label, Some(tmp));
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to true branch {:?}", cond),
+        }
+        Ok(())
+    }
+    fn emit_on_true_label_far(
+        &mut self,
+        cond: Location,
+        label: Label,
+        tmp: GPR,
+    ) -> Result<(), CompileError> {
+        let cont: Label = self.get_label();
+        let jump_label: Label = self.get_label();
+        match cond {
+            Location::GPR(cond) => {
+                dynasm!(self; bnez X(cond), => jump_label);
+            }
+            _ if cond.is_imm() => {
+                let imm = cond.imm_value_scalar().unwrap();
+                if imm == 1 {
+                    return self.emit_j_label(jump_label, Some(tmp));
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+
+        // skip over the jump to target
+        self.emit_j_label(cont, Some(tmp))?;
+
+        self.emit_label(jump_label)?;
+        self.emit_j_label(label, Some(tmp))?;
+
+        self.emit_label(cont)?;
+
+        Ok(())
+    }
+
+    fn emit_j_label(&mut self, label: Label, reg: Option<GPR>) -> Result<(), CompileError> {
+        if let Some(reg) = reg {
+            dynasm!(self ; jump => label, X(reg));
+        } else {
+            dynasm!(self ; j => label);
+        }
+        Ok(())
+    }
+
+    fn emit_j_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; jalr zero, X(reg), 0);
+        Ok(())
+    }
+
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; call =>label);
+        Ok(())
+    }
+
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; jalr ra, X(reg), 0);
+        Ok(())
+    }
+
+    fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; la X(reg), => label);
+        Ok(())
+    }
+
+    fn emit_rwfence(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; fence rw, rw);
+        Ok(())
+    }
+
+    fn emit_atomic_binop(
+        &mut self,
+        op: AtomicBinaryOp,
+        size: Size,
+        dest: GPR,
+        addr: GPR,
+        source: GPR,
+    ) -> Result<(), CompileError> {
+        match (size, op) {
+            (Size::S64, AtomicBinaryOp::Add) => {
+                dynasm!(self ; amoadd.d.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S64, AtomicBinaryOp::Or) => {
+                dynasm!(self ; amoor.d.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S64, AtomicBinaryOp::Xor) => {
+                dynasm!(self ; amoxor.d.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S64, AtomicBinaryOp::And) => {
+                dynasm!(self ; amoand.d.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S64, AtomicBinaryOp::Exchange) => {
+                dynasm!(self ; amoswap.d.aqrl X(dest), X(source), [X(addr)])
+            }
+
+            (Size::S32, AtomicBinaryOp::Add) => {
+                dynasm!(self ; amoadd.w.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S32, AtomicBinaryOp::Or) => {
+                dynasm!(self ; amoor.w.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S32, AtomicBinaryOp::Xor) => {
+                dynasm!(self ; amoxor.w.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S32, AtomicBinaryOp::And) => {
+                dynasm!(self ; amoand.w.aqrl X(dest), X(source), [X(addr)])
+            }
+            (Size::S32, AtomicBinaryOp::Exchange) => {
+                dynasm!(self ; amoswap.w.aqrl X(dest), X(source), [X(addr)])
+            }
+            _ => codegen_error!("singlepass can't emit atomic binop {:?} {:?}", size, op),
+        }
+
+        Ok(())
+    }
+
+    fn emit_reserved_ld(&mut self, size: Size, reg: GPR, addr: GPR) -> Result<(), CompileError> {
+        match size {
+            Size::S32 => {
+                dynasm!(self ; lr.w.aqrl X(reg), [X(addr)])
+            }
+            Size::S64 => {
+                dynasm!(self ; lr.d.aqrl X(reg), [X(addr)])
+            }
+            _ => codegen_error!("singlepass can't emit atomic reserved ld {:?}", size),
+        }
+
+        Ok(())
+    }
+
+    fn emit_reserved_sd(
+        &mut self,
+        size: Size,
+        dest: GPR,
+        addr: GPR,
+        source: GPR,
+    ) -> Result<(), CompileError> {
+        match size {
+            Size::S32 => {
+                dynasm!(self ; sc.w.rl X(dest), X(source), [X(addr)])
+            }
+            Size::S64 => {
+                dynasm!(self ; sc.d.rl X(dest), X(source), [X(addr)])
+            }
+            _ => codegen_error!("singlepass can't emit atomic reserved sd {:?}", size),
+        }
+
+        Ok(())
+    }
+}
+
+pub fn gen_std_trampoline_riscv(
+    sig: &FunctionType,
+    _calling_convention: CallingConvention,
+) -> Result<FunctionBody, CompileError> {
+    let mut a = Assembler::new(0);
+
+    // Callee-save registers must be used.
+    let fptr = GPR::X26;
+    let args = GPR::X27;
+
+    dynasm!(a
+        ; addi sp, sp, -32
+        ; sd s0, [sp,24]
+        ; sd ra, [sp,16]
+        ; sd X(fptr), [sp, 8]
+        ; sd X(args), [sp, 0]
+        ; mv s0, sp // use frame-pointer register for later restore
+        ; mv X(fptr), a1
+        ; mv X(args), a2
+    );
+
+    let stack_args = sig.params().len().saturating_sub(7); //1st arg is ctx, not an actual arg
+    let stack_return_slots = sig
+        .results()
+        .len()
+        .saturating_sub(RISCV_RETURN_VALUE_REGISTERS.len());
+    let mut stack_offset = (stack_args + stack_return_slots) as u32 * 8;
+    if stack_offset > 0 {
+        stack_offset = stack_offset.next_multiple_of(16);
+        if ImmType::Bits12Subtraction.compatible_imm(stack_offset as _) {
+            dynasm!(a ; addi sp, sp, -(stack_offset as i32));
+        } else {
+            a.emit_mov_imm(Location::GPR(SCRATCH_REG), stack_offset as _)?;
+            dynasm!(a ; sub sp, sp, X(SCRATCH_REG));
+        }
+    }
+
+    // Move arguments to their locations.
+    // `callee_vmctx` is already in the first argument register, so no need to move.
+    let mut caller_stack_offset: i32 = stack_return_slots as i32 * 8;
+    for (i, param) in sig.params().iter().enumerate() {
+        let sz = match *param {
+            Type::I32 | Type::F32 => Size::S32,
+            Type::I64 | Type::F64 => Size::S64,
+            Type::ExternRef => Size::S64,
+            Type::FuncRef => Size::S64,
+            _ => codegen_error!(
+                "singlepass unsupported param type for trampoline {:?}",
+                *param
+            ),
+        };
+        match i {
+            0..=6 => {
+                a.emit_ld(
+                    sz,
+                    false,
+                    Location::GPR(GPR::from_index(i + 10 + 1).unwrap()),
+                    Location::Memory(args, (i * 16) as i32),
+                )?;
+            }
+            _ => {
+                let args_offset = (i * 16) as i32;
+                let arg_location = if ImmType::Bits12.compatible_imm(args_offset as i64) {
+                    Location::Memory(args, args_offset)
+                } else {
+                    a.emit_mov_imm(Location::GPR(SCRATCH_REG), args_offset as i64)?;
+                    a.emit_add(
+                        Size::S64,
+                        Location::GPR(args),
+                        Location::GPR(SCRATCH_REG),
+                        Location::GPR(SCRATCH_REG),
+                    )?;
+                    Location::Memory(SCRATCH_REG, 0)
+                };
+                a.emit_ld(sz, false, Location::GPR(SCRATCH_REG), arg_location)?;
+
+                let arg_dest_location =
+                    if ImmType::Bits12.compatible_imm(caller_stack_offset as i64) {
+                        Location::Memory(GPR::Sp, caller_stack_offset)
+                    } else {
+                        a.emit_mov_imm(Location::GPR(GPR::X29), caller_stack_offset as i64)?;
+                        a.emit_add(
+                            Size::S64,
+                            Location::GPR(GPR::X29),
+                            Location::GPR(GPR::Sp),
+                            Location::GPR(GPR::X29),
+                        )?;
+                        Location::Memory(GPR::X29, 0)
+                    };
+                a.emit_sd(sz, Location::GPR(SCRATCH_REG), arg_dest_location)?;
+                caller_stack_offset += 8;
+            }
+        }
+    }
+
+    dynasm!(a
+        ; jalr ra, X(fptr), 0);
+
+    // Write return values.
+    let mut n_stack_return_slots: usize = 0;
+    for i in 0..sig.results().len() {
+        let src = if let Some(&reg) = RISCV_RETURN_VALUE_REGISTERS.get(i) {
+            reg
+        } else {
+            a.emit_ld(
+                Size::S64,
+                false,
+                Location::GPR(SCRATCH_REG),
+                Location::Memory(GPR::Sp, (n_stack_return_slots as u32 * 8) as _),
+            )?;
+            n_stack_return_slots += 1;
+            SCRATCH_REG
+        };
+        a.emit_sd(
+            Size::S64,
+            Location::GPR(src),
+            Location::Memory(args, (i * 16) as _),
+        )?;
+    }
+
+    // Restore stack.
+    dynasm!(a
+        ; ld X(args), [s0,0]
+        ; ld X(fptr), [s0,8]
+        ; ld ra, [s0,16]
+        ; ld s0, [s0,24]
+    );
+    let restored_stack_offset = 32 + stack_offset;
+    if ImmType::Bits12.compatible_imm(restored_stack_offset as _) {
+        dynasm!(a; addi sp, sp, restored_stack_offset as _);
+    } else {
+        a.emit_mov_imm(Location::GPR(SCRATCH_REG), restored_stack_offset as _)?;
+        dynasm!(a; add sp, sp, X(SCRATCH_REG));
+    }
+    dynasm!(a; ret);
+
+    let mut body = a.finalize().unwrap();
+
+    body.shrink_to_fit();
+    Ok(FunctionBody {
+        body,
+        unwind_info: None,
+    })
+}
+
+/// Generates dynamic import function call trampoline for a function type.
+pub fn gen_std_dynamic_import_trampoline_riscv(
+    vmoffsets: &VMOffsets,
+    sig: &FunctionType,
+) -> Result<FunctionBody, CompileError> {
+    let mut a = Assembler::new(0);
+    // Allocate argument array.
+    let stack_offset: usize = 16 * std::cmp::max(sig.params().len(), sig.results().len());
+
+    // Save RA and the scratch register
+    a.emit_push(Size::S64, Location::GPR(GPR::X1))?;
+    a.emit_push(Size::S64, Location::GPR(SCRATCH_REG))?;
+
+    if stack_offset != 0 {
+        if ImmType::Bits12Subtraction.compatible_imm(stack_offset as _) {
+            a.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::Sp),
+                Location::Imm64(stack_offset as _),
+                Location::GPR(GPR::Sp),
+            )?;
+        } else {
+            a.emit_mov_imm(Location::GPR(SCRATCH_REG), stack_offset as _)?;
+            a.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::Sp),
+                Location::GPR(SCRATCH_REG),
+                Location::GPR(GPR::Sp),
+            )?;
+        }
+    }
+
+    // Copy arguments.
+    if !sig.params().is_empty() {
+        let mut argalloc = ArgumentRegisterAllocator::default();
+        argalloc.next(Type::I64).unwrap(); // skip VMContext
+
+        let mut stack_param_count: usize = 0;
+
+        for (i, ty) in sig.params().iter().enumerate() {
+            let source_loc = match argalloc.next(*ty)? {
+                Some(RiscvRegister::GPR(gpr)) => Location::GPR(gpr),
+                Some(RiscvRegister::FPR(fpr)) => Location::SIMD(fpr),
+                None => {
+                    a.emit_ld(
+                        Size::S64,
+                        false,
+                        Location::GPR(SCRATCH_REG),
+                        Location::Memory(GPR::Sp, (stack_offset + 16 + stack_param_count) as _),
+                    )?;
+                    stack_param_count += 8;
+                    Location::GPR(SCRATCH_REG)
+                }
+            };
+            a.emit_sd(
+                Size::S64,
+                source_loc,
+                Location::Memory(GPR::Sp, (i * 16) as _),
+            )?;
+            // Zero upper 64 bits.
+            a.emit_sd(
+                Size::S64,
+                Location::GPR(GPR::XZero),
+                Location::Memory(GPR::Sp, (i * 16 + 8) as _),
+            )?;
+        }
+    }
+
+    // Load target address.
+    let offset = vmoffsets.vmdynamicfunction_import_context_address();
+    a.emit_ld(
+        Size::S64,
+        false,
+        Location::GPR(SCRATCH_REG),
+        Location::Memory(GPR::X10, offset as i32),
+    )?;
+    // Load values array.
+    a.emit_add(
+        Size::S64,
+        Location::GPR(GPR::Sp),
+        Location::Imm64(0),
+        Location::GPR(GPR::X11),
+    )?;
+
+    // Call target.
+    a.emit_call_register(SCRATCH_REG)?;
+
+    // Fetch return value.
+    if !sig.results().is_empty() {
+        assert_eq!(sig.results().len(), 1);
+        a.emit_ld(
+            Size::S64,
+            false,
+            Location::GPR(GPR::X10),
+            Location::Memory(GPR::Sp, 0),
+        )?;
+    }
+
+    // Release values array.
+    if stack_offset != 0 {
+        if ImmType::Bits12.compatible_imm(stack_offset as _) {
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::Sp),
+                Location::Imm64(stack_offset as _),
+                Location::GPR(GPR::Sp),
+            )?;
+        } else {
+            a.emit_mov_imm(Location::GPR(SCRATCH_REG), stack_offset as _)?;
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::Sp),
+                Location::GPR(SCRATCH_REG),
+                Location::GPR(GPR::Sp),
+            )?;
+        }
+    }
+    a.emit_pop(Size::S64, Location::GPR(SCRATCH_REG))?;
+    a.emit_pop(Size::S64, Location::GPR(GPR::X1))?;
+
+    // Return.
+    a.emit_ret()?;
+
+    let mut body = a.finalize().unwrap();
+    body.shrink_to_fit();
+    Ok(FunctionBody {
+        body,
+        unwind_info: None,
+    })
+}
+
+// Singlepass calls import functions through a trampoline.
+pub fn gen_import_call_trampoline_riscv(
+    vmoffsets: &VMOffsets,
+    index: FunctionIndex,
+    sig: &FunctionType,
+    _calling_convention: CallingConvention,
+) -> Result<CustomSection, CompileError> {
+    let mut a = Assembler::new(0);
+
+    // Singlepass internally treats all arguments as integers
+    // For the standard System V calling convention requires
+    //  floating point arguments to be passed in FPR registers.
+    //  Translation is expensive, so only do it if needed.
+    if sig
+        .params()
+        .iter()
+        .any(|&x| x == Type::F32 || x == Type::F64)
+    {
+        const PARAM_REGS: &[GPR] = &[
+            // X10 is skipped intentionally
+            GPR::X11,
+            GPR::X12,
+            GPR::X13,
+            GPR::X14,
+            GPR::X15,
+            GPR::X16,
+            GPR::X17,
+        ];
+        const PARAM_REGS_COUNT: usize = PARAM_REGS.len();
+
+        // Allocate stack space for arguments.
+        let stack_offset: i32 = if sig.params().len() > PARAM_REGS_COUNT {
+            (PARAM_REGS_COUNT * 8) as i32
+        } else {
+            (sig.params().len() as i32) * 8
+        };
+        if stack_offset > 0 {
+            if ImmType::Bits12Subtraction.compatible_imm(stack_offset as _) {
+                a.emit_sub(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::Imm64(stack_offset as _),
+                    Location::GPR(GPR::Sp),
+                )?;
+            } else {
+                a.emit_mov_imm(Location::GPR(SCRATCH_REG), stack_offset as _)?;
+                a.emit_sub(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::GPR(SCRATCH_REG),
+                    Location::GPR(GPR::Sp),
+                )?;
+            }
+        }
+
+        // Store all arguments to the stack to prevent overwrite.
+
+        let mut param_locations = vec![];
+        /* Clippy is wrong about using `i` to index `PARAM_REGS` here. */
+        #[allow(clippy::needless_range_loop)]
+        for i in 0..sig.params().len() {
+            let loc = match i {
+                0..PARAM_REGS_COUNT => {
+                    let loc = Location::Memory(GPR::Sp, (i * 8) as i32);
+                    a.emit_sd(Size::S64, Location::GPR(PARAM_REGS[i]), loc)?;
+                    loc
+                }
+                _ => Location::Memory(GPR::Sp, stack_offset + ((i - PARAM_REGS_COUNT) * 8) as i32),
+            };
+            param_locations.push(loc);
+        }
+
+        // Copy arguments.
+        let mut caller_stack_offset: i32 = 0;
+        let mut argalloc = ArgumentRegisterAllocator::default();
+        argalloc.next(Type::I64).unwrap(); // skip VMContext
+        for (i, ty) in sig.params().iter().enumerate() {
+            let prev_loc = param_locations[i];
+            let targ = match argalloc.next(*ty)? {
+                Some(RiscvRegister::GPR(gpr)) => Location::GPR(gpr),
+                Some(RiscvRegister::FPR(neon)) => Location::SIMD(neon),
+                None => {
+                    // No register can be allocated. Put this argument on the stack.
+                    a.emit_ld(Size::S64, false, Location::GPR(SCRATCH_REG), prev_loc)?;
+                    a.emit_sd(
+                        Size::S64,
+                        Location::GPR(SCRATCH_REG),
+                        Location::Memory(GPR::Sp, stack_offset + caller_stack_offset),
+                    )?;
+                    caller_stack_offset += 8;
+                    continue;
+                }
+            };
+            a.emit_ld(Size::S64, false, targ, prev_loc)?;
+        }
+
+        // Restore stack pointer.
+        if stack_offset > 0 {
+            if ImmType::Bits12.compatible_imm(stack_offset as _) {
+                a.emit_add(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::Imm64(stack_offset as _),
+                    Location::GPR(GPR::Sp),
+                )?;
+            } else {
+                a.emit_mov_imm(Location::GPR(SCRATCH_REG), stack_offset as _)?;
+                a.emit_add(
+                    Size::S64,
+                    Location::GPR(GPR::Sp),
+                    Location::GPR(SCRATCH_REG),
+                    Location::GPR(GPR::Sp),
+                )?;
+            }
+        }
+    }
+
+    // Emits a tail call trampoline that loads the address of the target import function
+    // from Ctx and jumps to it.
+
+    let offset = vmoffsets.vmctx_vmfunction_import(index);
+
+    a.emit_ld(
+        Size::S64,
+        false,
+        Location::GPR(SCRATCH_REG),
+        Location::Memory(GPR::X10, offset as i32), // function pointer
+    )?;
+    a.emit_ld(
+        Size::S64,
+        false,
+        Location::GPR(GPR::X10),
+        Location::Memory(GPR::X10, offset as i32 + 8), // target vmctx
+    )?;
+
+    a.emit_j_register(SCRATCH_REG)?;
+
+    let mut contents = a.finalize().unwrap();
+    contents.shrink_to_fit();
+    let section_body = SectionBody::new_with_vec(contents);
+
+    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..a4cbcd46e8 100644
--- a/lib/compiler-singlepass/src/emitter_x64.rs
+++ b/lib/compiler-singlepass/src/emitter_x64.rs
@@ -1,13 +1,14 @@
-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 dynasm::dynasm;
+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 dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi};
-use wasmer_types::{CompileError, CpuFeature};
+use wasmer_types::{CompileError, target::CpuFeature};
 
 /// 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 +62,7 @@ pub enum Precision {
     Double,
 }
 
+#[allow(unused)]
 pub trait EmitterX64 {
     fn get_simd_arch(&self) -> Option<&CpuFeature>;
     fn get_label(&mut self) -> Label;
@@ -166,9 +168,9 @@ pub trait EmitterX64 {
     fn emit_vminsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
 
     fn emit_vcmpeqss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_vcmpeqsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
 
     fn emit_vcmpneqss(
         &mut self,
@@ -184,24 +186,24 @@ pub trait EmitterX64 {
     ) -> Result<(), CompileError>;
 
     fn emit_vcmpltss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_vcmpltsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
 
     fn emit_vcmpless(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_vcmplesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
 
     fn emit_vcmpgtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_vcmpgtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
 
     fn emit_vcmpgess(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
     fn emit_vcmpgesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
-        -> Result<(), CompileError>;
+    -> Result<(), CompileError>;
 
     fn emit_vcmpunordss(
         &mut self,
@@ -442,14 +444,6 @@ pub trait EmitterX64 {
         codegen_error!("singlepass arch_emit_tzcnt unimplemented")
     }
 
-    fn arch_supports_canonicalize_nan(&self) -> bool {
-        true
-    }
-
-    fn arch_requires_indirect_call_trampoline(&self) -> bool {
-        false
-    }
-
     fn arch_emit_indirect_call_with_trampoline(
         &mut self,
         _loc: Location,
@@ -473,10 +467,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 +481,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 +503,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 +517,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 +531,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 +542,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 +556,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 +570,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 +598,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 +644,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 +687,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 +731,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 +747,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 +761,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 +805,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 +819,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 +863,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 +876,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 +889,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)
             },
         }
     }
@@ -906,7 +900,7 @@ macro_rules! sse_round_fn {
 
 impl EmitterX64 for AssemblerX64 {
     fn get_simd_arch(&self) -> Option<&CpuFeature> {
-        self.simd_arch.as_ref()
+        Some(&self.simd_arch)
     }
 
     fn get_label(&mut self) -> DynamicLabel {
@@ -925,11 +919,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 +1023,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 +1031,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 +1119,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 +1165,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 +1205,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 +1232,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,14 +1242,20 @@ 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),
         }
         Ok(())
     }
+
+    /// Emit a CMP instruction that compares `left` against `right`.
+    ///
+    /// Note: callers sometimes pass operands in the opposite order compared
+    /// to other binary operators. This function performs the comparison as
+    /// provided (i.e. it emits `cmp left, right` semantics).
     fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) -> Result<(), CompileError> {
         // Constant elimination for comparison between consts.
         //
@@ -1303,21 +1303,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 +1332,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 +1428,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 +1501,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 +1546,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 +1594,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 +1623,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 +1649,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 +1687,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 +2254,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 +2287,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 +2310,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 +2320,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 +2330,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 +2340,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 +2350,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 +2360,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 +2377,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 +2397,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/lib.rs b/lib/compiler-singlepass/src/lib.rs
index 2ea4cf7262..3c56973582 100644
--- a/lib/compiler-singlepass/src/lib.rs
+++ b/lib/compiler-singlepass/src/lib.rs
@@ -9,7 +9,7 @@
 //! runtime performance.
 
 #![allow(clippy::unnecessary_cast)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod address_map;
 mod arm64_decl;
@@ -20,15 +20,18 @@ mod config;
 #[cfg(feature = "unwind")]
 mod dwarf;
 mod emitter_arm64;
+mod emitter_riscv;
 mod emitter_x64;
 mod location;
 mod machine;
 mod machine_arm64;
+mod machine_riscv;
 mod machine_x64;
+mod riscv_decl;
 mod unwind;
 #[cfg(feature = "unwind")]
 mod unwind_winx64;
 mod x64_decl;
 
 pub use crate::compiler::SinglepassCompiler;
-pub use crate::config::Singlepass;
+pub use {crate::config::Singlepass, crate::config::SinglepassCallbacks};
diff --git a/lib/compiler-singlepass/src/location.rs b/lib/compiler-singlepass/src/location.rs
index ba8addfd6b..2c8c061db8 100644
--- a/lib/compiler-singlepass/src/location.rs
+++ b/lib/compiler-singlepass/src/location.rs
@@ -1,4 +1,3 @@
-use crate::common_decl::RegisterIndex;
 use crate::machine::*;
 use std::fmt::Debug;
 use std::hash::Hash;
@@ -36,17 +35,28 @@ impl<R, S> MaybeImmediate for Location<R, S> {
             _ => None,
         }
     }
+
+    fn imm_value_scalar(&self) -> Option<i64> {
+        match *self {
+            Location::Imm8(imm) => Some(imm as _),
+            Location::Imm32(imm) => Some(imm as _),
+            Location::Imm64(imm) => Some(imm as _),
+            _ => None,
+        }
+    }
 }
 
+#[allow(unused)]
 pub trait Reg: Copy + Clone + Eq + PartialEq + Debug + Hash + Ord {
-    fn is_callee_save(self) -> bool;
-    fn is_reserved(self) -> bool;
     fn into_index(self) -> usize;
     fn from_index(i: usize) -> Result<Self, ()>;
     fn iterator() -> Iter<'static, Self>;
-    fn to_dwarf(self) -> u16;
+
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register;
 }
 
+#[allow(unused)]
 pub trait Descriptor<R: Reg, S: Reg> {
     const FP: R;
     const VMCTX: R;
@@ -65,11 +75,8 @@ 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;
-    /// Converts a DWARF regnum to CombinedRegister.
-    fn _from_dwarf_regnum(x: u16) -> Option<Self>;
     /// Convert from a GPR register
     fn from_gpr(x: u16) -> Self;
     /// Convert from an SIMD register
diff --git a/lib/compiler-singlepass/src/machine.rs b/lib/compiler-singlepass/src/machine.rs
index e3ca24ba30..215516d479 100644
--- a/lib/compiler-singlepass/src/machine.rs
+++ b/lib/compiler-singlepass/src/machine.rs
@@ -1,19 +1,30 @@
-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_riscv::MachineRiscv,
+    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, HashMap},
+    fmt::Debug,
+};
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationTarget},
+        section::CustomSection,
+    },
+    wasmparser::MemArg,
+};
 use wasmer_types::{
-    Architecture, CallingConvention, CompileError, CustomSection, FunctionBody, FunctionIndex,
-    FunctionType, InstructionAddressMap, Relocation, RelocationTarget, Target, TrapCode,
-    TrapInformation, VMOffsets,
+    CompileError, FunctionIndex, FunctionType, TrapCode, TrapInformation, VMOffsets,
+    target::{Architecture, CallingConvention, Target},
 };
-
 pub type Label = DynamicLabel;
 pub type Offset = AssemblyOffset;
 
@@ -32,11 +43,13 @@ 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 {
         self.imm_value().is_some()
     }
+    fn imm_value_scalar(&self) -> Option<i64>;
 }
 
 /// A trap table for a `RunnableModuleInfo`.
@@ -49,17 +62,48 @@ pub struct TrapTable {
 // all machine seems to have a page this size, so not per arch for now
 pub const NATIVE_PAGE_SIZE: usize = 4096;
 
-pub struct MachineStackOffset(pub usize);
+#[allow(dead_code)]
+pub enum UnsignedCondition {
+    Equal,
+    NotEqual,
+    Above,
+    AboveEqual,
+    Below,
+    BelowEqual,
+}
+
+#[derive(Debug, Clone)]
+pub enum AssemblyComment {
+    FunctionPrologue,
+    InitializeLocals,
+    TrapHandlersTable,
+    RedZone,
+    FunctionBody,
+}
+
+impl std::fmt::Display for AssemblyComment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AssemblyComment::FunctionPrologue => write!(f, "function prologue"),
+            AssemblyComment::InitializeLocals => write!(f, "initialize locals"),
+            AssemblyComment::TrapHandlersTable => write!(f, "trap handlers table"),
+            AssemblyComment::RedZone => write!(f, "red zone"),
+            AssemblyComment::FunctionBody => write!(f, "body"),
+        }
+    }
+}
+
+pub(crate) struct FinalizedAssembly {
+    pub(crate) body: Vec<u8>,
+    pub(crate) assembly_comments: HashMap<usize, AssemblyComment>,
+}
 
+#[allow(unused)]
 pub trait Machine {
     type GPR: Copy + Eq + Debug + Reg;
     type SIMD: Copy + Eq + Debug + Reg;
     /// Get current assembler offset
     fn assembler_get_offset(&self) -> Offset;
-    /// Convert from a GPR register to index register
-    fn index_from_gpr(&self, x: Self::GPR) -> RegisterIndex;
-    /// Convert from an SIMD register
-    fn index_from_simd(&self, x: Self::SIMD) -> RegisterIndex;
     /// Get the GPR that hold vmctx
     fn get_vmctx_reg(&self) -> Self::GPR;
     /// Picks an unused general purpose register for local/stack/argument use.
@@ -82,10 +126,10 @@ pub trait Machine {
     fn reserve_unused_temp_gpr(&mut self, gpr: Self::GPR) -> Self::GPR;
     /// reserve a GPR
     fn reserve_gpr(&mut self, gpr: Self::GPR);
-    /// Push used gpr to the stack. Return the bytes taken on the stack
-    fn push_used_gpr(&mut self, grps: &[Self::GPR]) -> Result<usize, CompileError>;
-    /// Pop used gpr to the stack
-    fn pop_used_gpr(&mut self, grps: &[Self::GPR]) -> Result<(), CompileError>;
+    /// Push used gpr to the stack. Return the bytes taken on the stack.
+    fn push_used_gpr(&mut self, gprs: &[Self::GPR]) -> Result<usize, CompileError>;
+    /// Pop used gpr from the stack.
+    fn pop_used_gpr(&mut self, gprs: &[Self::GPR]) -> Result<(), CompileError>;
     /// Picks an unused SIMD register.
     ///
     /// This method does not mark the register as used
@@ -126,15 +170,10 @@ pub trait Machine {
     /// Memory location for a local on the stack
     /// Like Location::Memory(GPR::RBP, -(self.stack_offset.0 as i32)) for x86_64
     fn local_on_stack(&mut self, stack_offset: i32) -> Location<Self::GPR, Self::SIMD>;
-    /// Adjust stack for locals
-    /// Like assembler.emit_sub(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
-    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
-    /// restore stack
-    /// Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
-    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
-    /// Pop stack of locals
-    /// Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
-    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
+    /// Allocate an extra space on the stack.
+    fn extend_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
+    /// Truncate stack space by the `delta_stack_offset`.
+    fn truncate_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
     /// Zero a location taht is 32bits
     fn zero_location(
         &mut self,
@@ -170,6 +209,8 @@ pub trait Machine {
         &self,
         calling_convention: CallingConvention,
     ) -> Vec<Location<Self::GPR, Self::SIMD>>;
+    /// Get registers for first N function call parameters.
+    fn get_param_registers(&self, calling_convention: CallingConvention) -> &'static [Self::GPR];
     /// Get param location (to build a call, using SP for stack args)
     fn get_param_location(
         &self,
@@ -181,16 +222,30 @@ pub trait Machine {
     /// Get call param location (from a call, using FP for stack args)
     fn get_call_param_location(
         &self,
+        result_slots: usize,
         idx: usize,
         sz: Size,
         stack_offset: &mut usize,
         calling_convention: CallingConvention,
     ) -> Location<Self::GPR, Self::SIMD>;
-    /// Get simple param location
+    /// Get param location (idx must point to an argument that is passed in a GPR).
     fn get_simple_param_location(
         &self,
         idx: usize,
         calling_convention: CallingConvention,
+    ) -> Self::GPR;
+    /// Get return value location (to build a call, using SP for stack return values).
+    fn get_return_value_location(
+        &self,
+        idx: usize,
+        stack_location: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location<Self::GPR, Self::SIMD>;
+    /// Get return value location (from a call, using FP for stack return values).
+    fn get_call_return_value_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
     ) -> Location<Self::GPR, Self::SIMD>;
     /// move a location to another
     fn move_location(
@@ -208,14 +263,6 @@ pub trait Machine {
         size_op: Size,
         dest: Location<Self::GPR, Self::SIMD>,
     ) -> Result<(), CompileError>;
-    /// Load a memory value to a register, zero extending to 64bits.
-    /// Panic if gpr is not a Location::GPR or if mem is not a Memory(2)
-    fn load_address(
-        &mut self,
-        size: Size,
-        gpr: Location<Self::GPR, Self::SIMD>,
-        mem: Location<Self::GPR, Self::SIMD>,
-    ) -> Result<(), CompileError>;
     /// Init the stack loc counter
     fn init_stack_loc(
         &mut self,
@@ -229,11 +276,12 @@ pub trait Machine {
         &mut self,
         location: Location<Self::GPR, Self::SIMD>,
     ) -> Result<(), CompileError>;
-    /// Create a new `MachineState` with default values.
-    fn new_machine_state(&self) -> MachineState;
 
     /// Finalize the assembler
-    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError>;
+    fn assembler_finalize(
+        self,
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<FinalizedAssembly, CompileError>;
 
     /// get_offset of Assembler
     fn get_offset(&self) -> Offset;
@@ -245,17 +293,8 @@ pub trait Machine {
     fn emit_function_prolog(&mut self) -> Result<(), CompileError>;
     /// emit native function epilog (depending on the calling Convention, like "MOV RBP, RSP / POP RBP")
     fn emit_function_epilog(&mut self) -> Result<(), CompileError>;
-    /// handle return value, with optionnal cannonicalization if wanted
-    fn emit_function_return_value(
-        &mut self,
-        ty: WpType,
-        cannonicalize: bool,
-        loc: Location<Self::GPR, Self::SIMD>,
-    ) -> Result<(), CompileError>;
     /// Handle copy to SIMD register from ret value (if needed by the arch/calling convention)
     fn emit_function_return_float(&mut self) -> Result<(), CompileError>;
-    /// Is NaN canonicalization supported
-    fn arch_supports_canonicalize_nan(&self) -> bool;
     /// Cannonicalize a NaN (or panic if not supported)
     fn canonicalize_nan(
         &mut self,
@@ -271,14 +310,12 @@ pub trait Machine {
     /// emit a label
     fn emit_label(&mut self, label: Label) -> Result<(), CompileError>;
 
-    /// get the gpr use for call. like RAX on x86_64
-    fn get_grp_for_call(&self) -> Self::GPR;
+    /// get the gpr used for call. like RAX on x86_64
+    fn get_gpr_for_call(&self) -> Self::GPR;
     /// Emit a call using the value in register
     fn emit_call_register(&mut self, register: Self::GPR) -> Result<(), CompileError>;
     /// Emit a call to a label
     fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError>;
-    /// Does an trampoline is neededfor indirect call
-    fn arch_requires_indirect_call_trampoline(&self) -> bool;
     /// indirect call with trampoline
     fn arch_emit_indirect_call_with_trampoline(
         &mut self,
@@ -289,48 +326,10 @@ pub trait Machine {
         &mut self,
         location: Location<Self::GPR, Self::SIMD>,
     ) -> Result<(), CompileError>;
-    /// get the gpr for the return of generic values
-    fn get_gpr_for_ret(&self) -> Self::GPR;
-    /// get the simd for the return of float/double values
-    fn get_simd_for_ret(&self) -> Self::SIMD;
 
     /// Emit a debug breakpoint
     fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError>;
 
-    /// load the address of a memory location (will panic if src is not a memory)
-    /// like LEA opcode on x86_64
-    fn location_address(
-        &mut self,
-        size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
-    ) -> Result<(), CompileError>;
-
-    /// And src & dst -> dst (with or without flags)
-    fn location_and(
-        &mut self,
-        size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
-        flags: bool,
-    ) -> Result<(), CompileError>;
-    /// Xor src & dst -> dst (with or without flags)
-    fn location_xor(
-        &mut self,
-        size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
-        flags: bool,
-    ) -> Result<(), CompileError>;
-    /// Or src & dst -> dst (with or without flags)
-    fn location_or(
-        &mut self,
-        size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
-        flags: bool,
-    ) -> Result<(), CompileError>;
-
     /// Add src+dst -> dst (with or without flags)
     fn location_add(
         &mut self,
@@ -339,23 +338,6 @@ pub trait Machine {
         dest: Location<Self::GPR, Self::SIMD>,
         flags: bool,
     ) -> Result<(), CompileError>;
-    /// Sub dst-src -> dst (with or without flags)
-    fn location_sub(
-        &mut self,
-        size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
-        flags: bool,
-    ) -> Result<(), CompileError>;
-    /// -src -> dst
-    fn location_neg(
-        &mut self,
-        size_val: Size, // size of src
-        signed: bool,
-        source: Location<Self::GPR, Self::SIMD>,
-        size_op: Size,
-        dest: Location<Self::GPR, Self::SIMD>,
-    ) -> Result<(), CompileError>;
 
     /// Cmp src - dst and set flags
     fn location_cmp(
@@ -364,35 +346,20 @@ pub trait Machine {
         source: Location<Self::GPR, Self::SIMD>,
         dest: Location<Self::GPR, Self::SIMD>,
     ) -> Result<(), CompileError>;
-    /// Test src & dst and set flags
-    fn location_test(
+
+    /// jmp without condidtion
+    fn jmp_unconditional(&mut self, label: Label) -> Result<(), CompileError>;
+
+    /// jmp to label if the provided condition is true (when comparing loc_a and loc_b)
+    fn jmp_on_condition(
         &mut self,
+        cond: UnsignedCondition,
         size: Size,
-        source: Location<Self::GPR, Self::SIMD>,
-        dest: Location<Self::GPR, Self::SIMD>,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        label: Label,
     ) -> Result<(), CompileError>;
 
-    /// jmp without condidtion
-    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on equal (src==dst)
-    /// like Equal set on x86_64
-    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on different (src!=dst)
-    /// like NotEqual set on x86_64
-    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on above (src>dst)
-    /// like Above set on x86_64
-    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on above (src>=dst)
-    /// like Above or Equal set on x86_64
-    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on above (src<=dst)
-    /// like Below or Equal set on x86_64
-    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError>;
-    /// jmp on overflow
-    /// like Carry set on x86_64
-    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError>;
-
     /// jmp using a jump table at lable with cond as the indice
     fn emit_jmp_to_jumptable(
         &mut self,
@@ -434,14 +401,6 @@ pub trait Machine {
     ) -> Result<(), CompileError>;
     /// Emit a memory fence. Can be nothing for x86_64 or a DMB on ARM64 for example
     fn emit_memory_fence(&mut self) -> Result<(), CompileError>;
-    /// relaxed move with zero extension
-    fn emit_relaxed_zero_extension(
-        &mut self,
-        sz_src: Size,
-        src: Location<Self::GPR, Self::SIMD>,
-        sz_dst: Size,
-        dst: Location<Self::GPR, Self::SIMD>,
-    ) -> Result<(), CompileError>;
     /// relaxed move with sign extension
     fn emit_relaxed_sign_extension(
         &mut self,
@@ -485,7 +444,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
     fn emit_binop_sdiv32(
@@ -503,7 +461,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
     fn emit_binop_srem32(
@@ -512,7 +469,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// And with location directly from the stack
     fn emit_binop_and32(
@@ -1172,7 +1128,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
     fn emit_binop_sdiv64(
@@ -1190,7 +1145,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
     fn emit_binop_srem64(
@@ -1199,7 +1153,6 @@ pub trait Machine {
         loc_b: Location<Self::GPR, Self::SIMD>,
         ret: Location<Self::GPR, Self::SIMD>,
         integer_division_by_zero: Label,
-        integer_overflow: Label,
     ) -> Result<usize, CompileError>;
     /// And with location directly from the stack
     fn emit_binop_and64(
@@ -2414,6 +2367,10 @@ pub fn gen_std_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_std_trampoline(sig, calling_convention)
         }
+        Architecture::Riscv64(_) => {
+            let machine = MachineRiscv::new(Some(target.clone()))?;
+            machine.gen_std_trampoline(sig, calling_convention)
+        }
         _ => Err(CompileError::UnsupportedTarget(
             "singlepass unimplemented arch for gen_std_trampoline".to_owned(),
         )),
@@ -2436,6 +2393,10 @@ pub fn gen_std_dynamic_import_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_std_dynamic_import_trampoline(vmoffsets, sig, calling_convention)
         }
+        Architecture::Riscv64(_) => {
+            let machine = MachineRiscv::new(Some(target.clone()))?;
+            machine.gen_std_dynamic_import_trampoline(vmoffsets, sig, calling_convention)
+        }
         _ => Err(CompileError::UnsupportedTarget(
             "singlepass unimplemented arch for gen_std_dynamic_import_trampoline".to_owned(),
         )),
@@ -2458,6 +2419,10 @@ pub fn gen_import_call_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_import_call_trampoline(vmoffsets, index, sig, calling_convention)
         }
+        Architecture::Riscv64(_) => {
+            let machine = MachineRiscv::new(Some(target.clone()))?;
+            machine.gen_import_call_trampoline(vmoffsets, index, sig, calling_convention)
+        }
         _ => Err(CompileError::UnsupportedTarget(
             "singlepass unimplemented arch for gen_import_call_trampoline".to_owned(),
         )),
diff --git a/lib/compiler-singlepass/src/machine_arm64.rs b/lib/compiler-singlepass/src/machine_arm64.rs
index a5341dd512..61a7d9f7e8 100644
--- a/lib/compiler-singlepass/src/machine_arm64.rs
+++ b/lib/compiler-singlepass/src/machine_arm64.rs
@@ -1,104 +1,36 @@
-use dynasmrt::{aarch64::Aarch64Relocation, VecAssembler};
-#[cfg(feature = "unwind")]
-use gimli::{write::CallFrameInstruction, AArch64};
+use std::collections::HashMap;
 
-use wasmer_compiler::wasmparser::ValType as WpType;
+use dynasmrt::{VecAssembler, aarch64::Aarch64Relocation};
+#[cfg(feature = "unwind")]
+use gimli::{AArch64, write::CallFrameInstruction};
+
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationKind, RelocationTarget},
+        section::CustomSection,
+    },
+    wasmparser::MemArg,
+};
 use wasmer_types::{
-    CallingConvention, CompileError, CpuFeature, CustomSection, FunctionBody, FunctionIndex,
-    FunctionType, InstructionAddressMap, Relocation, RelocationKind, RelocationTarget, SourceLoc,
-    Target, TrapCode, TrapInformation, VMOffsets,
+    CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, VMOffsets,
+    target::{CallingConvention, CpuFeature, Target},
 };
 
-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::{GPR, NEON},
+    codegen_error,
+    common_decl::*,
+    emitter_arm64::*,
+    location::{Location as AbstractLocation, Reg},
+    machine::*,
+    unwind::{UnwindInstructions, UnwindOps, UnwindRegister},
+};
 
 type Assembler = VecAssembler<Aarch64Relocation>;
 type Location = AbstractLocation<GPR, NEON>;
 
-#[cfg(feature = "unwind")]
-fn dwarf_index(reg: u16) -> gimli::Register {
-    static DWARF_GPR: [gimli::Register; 32] = [
-        AArch64::X0,
-        AArch64::X1,
-        AArch64::X2,
-        AArch64::X3,
-        AArch64::X4,
-        AArch64::X5,
-        AArch64::X6,
-        AArch64::X7,
-        AArch64::X8,
-        AArch64::X9,
-        AArch64::X10,
-        AArch64::X11,
-        AArch64::X12,
-        AArch64::X13,
-        AArch64::X14,
-        AArch64::X15,
-        AArch64::X16,
-        AArch64::X17,
-        AArch64::X18,
-        AArch64::X19,
-        AArch64::X20,
-        AArch64::X21,
-        AArch64::X22,
-        AArch64::X23,
-        AArch64::X24,
-        AArch64::X25,
-        AArch64::X26,
-        AArch64::X27,
-        AArch64::X28,
-        AArch64::X29,
-        AArch64::X30,
-        AArch64::SP,
-    ];
-    static DWARF_NEON: [gimli::Register; 32] = [
-        AArch64::V0,
-        AArch64::V1,
-        AArch64::V2,
-        AArch64::V3,
-        AArch64::V4,
-        AArch64::V5,
-        AArch64::V6,
-        AArch64::V7,
-        AArch64::V8,
-        AArch64::V9,
-        AArch64::V10,
-        AArch64::V11,
-        AArch64::V12,
-        AArch64::V13,
-        AArch64::V14,
-        AArch64::V15,
-        AArch64::V16,
-        AArch64::V17,
-        AArch64::V18,
-        AArch64::V19,
-        AArch64::V20,
-        AArch64::V21,
-        AArch64::V22,
-        AArch64::V23,
-        AArch64::V24,
-        AArch64::V25,
-        AArch64::V26,
-        AArch64::V27,
-        AArch64::V28,
-        AArch64::V29,
-        AArch64::V30,
-        AArch64::V31,
-    ];
-    match reg {
-        0..=31 => DWARF_GPR[reg as usize],
-        64..=95 => DWARF_NEON[reg as usize - 64],
-        _ => panic!("Unknown register index {}", reg),
-    }
-}
-
 pub struct MachineARM64 {
     assembler: Assembler,
     used_gprs: u32,
@@ -112,11 +44,24 @@ pub struct MachineARM64 {
     /// is last push on a 8byte multiple or 16bytes?
     pushed: bool,
     /// Vector of unwind operations with offset
-    unwind_ops: Vec<(usize, UnwindOps)>,
+    unwind_ops: Vec<(usize, UnwindOps<GPR, NEON>)>,
     /// A boolean flag signaling if this machine supports NEON.
     has_neon: bool,
 }
 
+/// Get registers for first N function return values.
+/// NOTE: The register set must be disjoint from pick_gpr registers!
+pub(crate) const ARM64_RETURN_VALUE_REGISTERS: [GPR; 8] = [
+    GPR::X0,
+    GPR::X1,
+    GPR::X2,
+    GPR::X3,
+    GPR::X4,
+    GPR::X5,
+    GPR::X6,
+    GPR::X7,
+];
+
 #[allow(dead_code)]
 #[derive(PartialEq)]
 enum ImmType {
@@ -566,7 +511,7 @@ impl MachineARM64 {
                     temps.push(tmp);
                 }
             }
-            _ => codegen_error!("singplass emit_relaxed_ldr64 unreachable"),
+            _ => codegen_error!("singlepass emit_relaxed_ldr64 unreachable"),
         }
         if dst != dest {
             self.move_location(sz, dest, dst)?;
@@ -1127,35 +1072,11 @@ impl MachineARM64 {
         Ok(())
     }
 
-    /*fn emit_compare_and_swap<F: FnOnce(&mut Self, GPR, GPR)>(
-        &mut self,
-        _loc: Location,
-        _target: Location,
-        _ret: Location,
-        _memarg: &MemArg,
-        _value_size: usize,
-        _memory_sz: Size,
-        _stack_sz: Size,
-        _need_check: bool,
-        _imported_memories: bool,
-        _offset: i32,
-        _heap_access_oob: Label,
-        _unaligned_atomic: Label,
-        _cb: F,
-    ) {
-        unimplemented!();
-    }*/
-
     fn offset_is_ok(&self, size: Size, offset: i32) -> bool {
         if offset < 0 {
             return false;
         }
-        let shift = match size {
-            Size::S8 => 0,
-            Size::S16 => 1,
-            Size::S32 => 2,
-            Size::S64 => 3,
-        };
+        let shift = size.bytes().trailing_zeros() as i32;
         if offset >= 0x1000 << shift {
             return false;
         }
@@ -1247,7 +1168,7 @@ impl MachineARM64 {
                 }
                 self.pushed = !self.pushed;
             }
-            _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", sz, dst),
+            _ => codegen_error!("singlepass can't emit POP {:?} {:?}", sz, dst),
         }
         Ok(())
     }
@@ -1403,7 +1324,7 @@ impl MachineARM64 {
         self.used_simd &= !(1 << r.into_index());
         ret
     }
-    fn emit_unwind_op(&mut self, op: UnwindOps) {
+    fn emit_unwind_op(&mut self, op: UnwindOps<GPR, NEON>) {
         self.unwind_ops.push((self.get_offset().0, op));
     }
     fn emit_illegal_op_internal(&mut self, trap: TrapCode) -> Result<(), CompileError> {
@@ -1417,12 +1338,6 @@ impl Machine for MachineARM64 {
     fn assembler_get_offset(&self) -> Offset {
         self.assembler.get_offset()
     }
-    fn index_from_gpr(&self, x: GPR) -> RegisterIndex {
-        RegisterIndex(x as usize)
-    }
-    fn index_from_simd(&self, x: NEON) -> RegisterIndex {
-        RegisterIndex(x as usize + 32)
-    }
 
     fn get_vmctx_reg(&self) -> GPR {
         GPR::X28
@@ -1494,7 +1409,7 @@ impl Machine for MachineARM64 {
         for r in used_gprs.iter() {
             self.emit_push(Size::S64, Location::GPR(*r))?;
         }
-        Ok(((used_gprs.len() + 1) / 2) * 16)
+        Ok(used_gprs.len().div_ceil(2) * 16)
     }
     fn pop_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<(), CompileError> {
         for r in used_gprs.iter().rev() {
@@ -1549,12 +1464,12 @@ impl Machine for MachineARM64 {
     }
 
     fn push_used_simd(&mut self, used_neons: &[NEON]) -> Result<usize, CompileError> {
-        let stack_adjust = if used_neons.len() & 1 == 1 {
+        let stack_adjust = if used_neons.len() % 2 == 1 {
             (used_neons.len() * 8) as u32 + 8
         } else {
             (used_neons.len() * 8) as u32
         };
-        self.adjust_stack(stack_adjust)?;
+        self.extend_stack(stack_adjust)?;
 
         for (i, r) in used_neons.iter().enumerate() {
             self.assembler.emit_str(
@@ -1573,7 +1488,7 @@ impl Machine for MachineARM64 {
                 Location::Memory(GPR::XzrSp, (i * 8) as i32),
             )?;
         }
-        let stack_adjust = if used_neons.len() & 1 == 1 {
+        let stack_adjust = if used_neons.len() % 2 == 1 {
             (used_neons.len() * 8) as u32 + 8
         } else {
             (used_neons.len() * 8) as u32
@@ -1648,11 +1563,7 @@ impl Machine for MachineARM64 {
 
     // Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)
     fn round_stack_adjust(&self, value: usize) -> usize {
-        if value & 0xf != 0 {
-            ((value >> 4) + 1) << 4
-        } else {
-            value
-        }
+        value.next_multiple_of(16)
     }
 
     // Memory location for a local on the stack
@@ -1660,8 +1571,7 @@ impl Machine for MachineARM64 {
         Location::Memory(GPR::X29, -stack_offset)
     }
 
-    // Adjust stack for locals
-    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+    fn extend_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
         let delta = if self.compatible_imm(delta_stack_offset as _, ImmType::Bits12) {
             Location::Imm32(delta_stack_offset as _)
         } else {
@@ -1677,8 +1587,8 @@ impl Machine for MachineARM64 {
             Location::GPR(GPR::XzrSp),
         )
     }
-    // restore stack
-    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+
+    fn truncate_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
         let delta = if self.compatible_imm(delta_stack_offset as _, ImmType::Bits12) {
             Location::Imm32(delta_stack_offset as _)
         } else {
@@ -1694,27 +1604,7 @@ impl Machine for MachineARM64 {
             Location::GPR(GPR::XzrSp),
         )
     }
-    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
-        let real_delta = if delta_stack_offset & 15 != 0 {
-            delta_stack_offset + 8
-        } else {
-            delta_stack_offset
-        };
-        let delta = if self.compatible_imm(real_delta as i64, ImmType::Bits12) {
-            Location::Imm32(real_delta as _)
-        } else {
-            let tmp = GPR::X17;
-            self.assembler
-                .emit_mov_imm(Location::GPR(tmp), real_delta as u64)?;
-            Location::GPR(tmp)
-        };
-        self.assembler.emit_add(
-            Size::S64,
-            Location::GPR(GPR::XzrSp),
-            delta,
-            Location::GPR(GPR::XzrSp),
-        )
-    }
+
     // push a value on the stack for a native call
     fn move_location_for_native(
         &mut self,
@@ -1795,11 +1685,11 @@ impl Machine for MachineARM64 {
         }
         match location {
             Location::GPR(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
-                reg: x.to_dwarf(),
+                reg: UnwindRegister::<GPR, NEON>::GPR(x),
                 bp_neg_offset: stack_offset,
             }),
             Location::SIMD(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
-                reg: x.to_dwarf(),
+                reg: UnwindRegister::FPR(x),
                 bp_neg_offset: stack_offset,
             }),
             _ => (),
@@ -1812,6 +1702,20 @@ impl Machine for MachineARM64 {
         vec![]
     }
 
+    /// Get registers for first N function call parameters.
+    fn get_param_registers(&self, _calling_convention: CallingConvention) -> &'static [Self::GPR] {
+        &[
+            GPR::X0,
+            GPR::X1,
+            GPR::X2,
+            GPR::X3,
+            GPR::X4,
+            GPR::X5,
+            GPR::X6,
+            GPR::X7,
+        ]
+    }
+
     // Get param location, MUST be called in order!
     fn get_param_location(
         &self,
@@ -1820,123 +1724,112 @@ impl Machine for MachineARM64 {
         stack_args: &mut usize,
         calling_convention: CallingConvention,
     ) -> Location {
+        let register_params = self.get_param_registers(calling_convention);
         match calling_convention {
-            CallingConvention::AppleAarch64 => match idx {
-                0 => Location::GPR(GPR::X0),
-                1 => Location::GPR(GPR::X1),
-                2 => Location::GPR(GPR::X2),
-                3 => Location::GPR(GPR::X3),
-                4 => Location::GPR(GPR::X4),
-                5 => Location::GPR(GPR::X5),
-                6 => Location::GPR(GPR::X6),
-                7 => Location::GPR(GPR::X7),
-                _ => {
-                    let sz = 1
-                        << match sz {
-                            Size::S8 => 0,
-                            Size::S16 => 1,
-                            Size::S32 => 2,
-                            Size::S64 => 3,
-                        };
+            CallingConvention::AppleAarch64 => register_params.get(idx).map_or_else(
+                || {
                     // align first
-                    if sz > 1 && *stack_args & (sz - 1) != 0 {
-                        *stack_args = (*stack_args + (sz - 1)) & !(sz - 1);
-                    }
+                    let sz = sz.bytes() as usize;
+                    *stack_args = (*stack_args).next_multiple_of(sz);
                     let loc = Location::Memory(GPR::XzrSp, *stack_args as i32);
                     *stack_args += sz;
                     loc
-                }
-            },
-            _ => match idx {
-                0 => Location::GPR(GPR::X0),
-                1 => Location::GPR(GPR::X1),
-                2 => Location::GPR(GPR::X2),
-                3 => Location::GPR(GPR::X3),
-                4 => Location::GPR(GPR::X4),
-                5 => Location::GPR(GPR::X5),
-                6 => Location::GPR(GPR::X6),
-                7 => Location::GPR(GPR::X7),
-                _ => {
+                },
+                |reg| Location::GPR(*reg),
+            ),
+            _ => {
+                if let Some(reg) = register_params.get(idx) {
+                    Location::GPR(*reg)
+                } else {
                     let loc = Location::Memory(GPR::XzrSp, *stack_args as i32);
                     *stack_args += 8;
                     loc
                 }
-            },
+            }
         }
     }
     // Get call param location, MUST be called in order!
     fn get_call_param_location(
         &self,
+        return_slots: usize,
         idx: usize,
         sz: Size,
         stack_args: &mut usize,
         calling_convention: CallingConvention,
     ) -> Location {
+        let register_params = self.get_param_registers(calling_convention);
+        let return_values_memory_size =
+            8 * return_slots.saturating_sub(ARM64_RETURN_VALUE_REGISTERS.len()) as i32;
+
         match calling_convention {
-            CallingConvention::AppleAarch64 => match idx {
-                0 => Location::GPR(GPR::X0),
-                1 => Location::GPR(GPR::X1),
-                2 => Location::GPR(GPR::X2),
-                3 => Location::GPR(GPR::X3),
-                4 => Location::GPR(GPR::X4),
-                5 => Location::GPR(GPR::X5),
-                6 => Location::GPR(GPR::X6),
-                7 => Location::GPR(GPR::X7),
-                _ => {
-                    let sz = 1
-                        << match sz {
-                            Size::S8 => 0,
-                            Size::S16 => 1,
-                            Size::S32 => 2,
-                            Size::S64 => 3,
-                        };
+            CallingConvention::AppleAarch64 => register_params.get(idx).map_or_else(
+                || {
+                    let sz = sz.bytes() as usize;
                     // align first
-                    if sz > 1 && *stack_args & (sz - 1) != 0 {
-                        *stack_args = (*stack_args + (sz - 1)) & !(sz - 1);
-                    }
-                    let loc = Location::Memory(GPR::X29, 16 * 2 + *stack_args as i32);
+                    *stack_args = (*stack_args).next_multiple_of(sz);
+                    let loc = Location::Memory(
+                        GPR::X29,
+                        16 * 2 + return_values_memory_size + *stack_args as i32,
+                    );
                     *stack_args += sz;
                     loc
-                }
-            },
-            _ => match idx {
-                0 => Location::GPR(GPR::X0),
-                1 => Location::GPR(GPR::X1),
-                2 => Location::GPR(GPR::X2),
-                3 => Location::GPR(GPR::X3),
-                4 => Location::GPR(GPR::X4),
-                5 => Location::GPR(GPR::X5),
-                6 => Location::GPR(GPR::X6),
-                7 => Location::GPR(GPR::X7),
-                _ => {
-                    let loc = Location::Memory(GPR::X29, 16 * 2 + *stack_args as i32);
+                },
+                |reg| Location::GPR(*reg),
+            ),
+            _ => register_params.get(idx).map_or_else(
+                || {
+                    let loc = Location::Memory(
+                        GPR::X29,
+                        16 * 2 + return_values_memory_size + *stack_args as i32,
+                    );
                     *stack_args += 8;
                     loc
-                }
-            },
+                },
+                |reg| Location::GPR(*reg),
+            ),
         }
     }
-    // Get simple param location, Will not be accurate for Apple calling convention on "stack" arguments
+
     fn get_simple_param_location(
         &self,
         idx: usize,
         calling_convention: CallingConvention,
-    ) -> Location {
-        #[allow(clippy::match_single_binding)]
-        match calling_convention {
-            _ => match idx {
-                0 => Location::GPR(GPR::X0),
-                1 => Location::GPR(GPR::X1),
-                2 => Location::GPR(GPR::X2),
-                3 => Location::GPR(GPR::X3),
-                4 => Location::GPR(GPR::X4),
-                5 => Location::GPR(GPR::X5),
-                6 => Location::GPR(GPR::X6),
-                7 => Location::GPR(GPR::X7),
-                _ => Location::Memory(GPR::X29, (16 * 2 + (idx - 8) * 8) as i32),
+    ) -> Self::GPR {
+        self.get_param_registers(calling_convention)[idx]
+    }
+
+    fn get_return_value_location(
+        &self,
+        idx: usize,
+        stack_location: &mut usize,
+        _calling_convention: CallingConvention,
+    ) -> AbstractLocation<Self::GPR, Self::SIMD> {
+        ARM64_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                let loc = Location::Memory(GPR::XzrSp, *stack_location as i32);
+                *stack_location += 8;
+                loc
             },
-        }
+            |reg| Location::GPR(*reg),
+        )
     }
+
+    fn get_call_return_value_location(
+        &self,
+        idx: usize,
+        _calling_convention: CallingConvention,
+    ) -> AbstractLocation<Self::GPR, Self::SIMD> {
+        ARM64_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                Location::Memory(
+                    GPR::X29,
+                    (16 * 2 + (idx - ARM64_RETURN_VALUE_REGISTERS.len()) * 8) as i32,
+                )
+            },
+            |reg| Location::GPR(*reg),
+        )
+    }
+
     // move a location to another
     fn move_location(
         &mut self,
@@ -2163,14 +2056,7 @@ impl Machine for MachineARM64 {
         }
         Ok(())
     }
-    fn load_address(
-        &mut self,
-        _size: Size,
-        _reg: Location,
-        _mem: Location,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass load_address unimplemented");
-    }
+
     // Init the stack loc counter
     fn init_stack_loc(
         &mut self,
@@ -2294,15 +2180,17 @@ impl Machine for MachineARM64 {
     fn pop_location(&mut self, location: Location) -> Result<(), CompileError> {
         self.emit_pop(Size::S64, location)
     }
-    // Create a new `MachineState` with default values.
-    fn new_machine_state(&self) -> MachineState {
-        new_machine_state()
-    }
 
     // assembler finalize
-    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
-        self.assembler.finalize().map_err(|e| {
-            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+    fn assembler_finalize(
+        self,
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<FinalizedAssembly, CompileError> {
+        Ok(FinalizedAssembly {
+            body: self.assembler.finalize().map_err(|e| {
+                CompileError::Codegen(format!("Assembler failed finalization with: {e:?}"))
+            })?,
+            assembly_comments,
         })
     }
 
@@ -2318,14 +2206,14 @@ impl Machine for MachineARM64 {
     fn emit_function_prolog(&mut self) -> Result<(), CompileError> {
         self.emit_double_push(Size::S64, Location::GPR(GPR::X29), Location::GPR(GPR::X30))?; // save LR too
         self.emit_unwind_op(UnwindOps::Push2Regs {
-            reg1: GPR::X29.to_dwarf(),
-            reg2: GPR::X30.to_dwarf(),
+            reg1: UnwindRegister::GPR(GPR::X29),
+            reg2: UnwindRegister::GPR(GPR::X30),
             up_to_sp: 16,
         });
         self.emit_double_push(Size::S64, Location::GPR(GPR::X27), Location::GPR(GPR::X28))?;
         self.emit_unwind_op(UnwindOps::Push2Regs {
-            reg1: GPR::X27.to_dwarf(),
-            reg2: GPR::X28.to_dwarf(),
+            reg1: UnwindRegister::GPR(GPR::X27),
+            reg2: UnwindRegister::GPR(GPR::X28),
             up_to_sp: 32,
         });
         // cannot use mov, because XSP is XZR there. Need to use ADD with #0
@@ -2353,36 +2241,11 @@ impl Machine for MachineARM64 {
         Ok(())
     }
 
-    fn emit_function_return_value(
-        &mut self,
-        ty: WpType,
-        canonicalize: bool,
-        loc: Location,
-    ) -> Result<(), CompileError> {
-        if canonicalize {
-            self.canonicalize_nan(
-                match ty {
-                    WpType::F32 => Size::S32,
-                    WpType::F64 => Size::S64,
-                    _ => unreachable!(),
-                },
-                loc,
-                Location::GPR(GPR::X0),
-            )?;
-        } else {
-            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(GPR::X0))?;
-        }
-        Ok(())
-    }
-
     fn emit_function_return_float(&mut self) -> Result<(), CompileError> {
         self.assembler
             .emit_mov(Size::S64, Location::GPR(GPR::X0), Location::SIMD(NEON::V0))
     }
 
-    fn arch_supports_canonicalize_nan(&self) -> bool {
-        self.assembler.arch_supports_canonicalize_nan()
-    }
     fn canonicalize_nan(
         &mut self,
         sz: Size,
@@ -2443,7 +2306,7 @@ impl Machine for MachineARM64 {
     fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_label(label)
     }
-    fn get_grp_for_call(&self) -> GPR {
+    fn get_gpr_for_call(&self) -> GPR {
         GPR::X27
     }
     fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
@@ -2452,16 +2315,6 @@ impl Machine for MachineARM64 {
     fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_call_label(label)
     }
-    fn get_gpr_for_ret(&self) -> GPR {
-        GPR::X0
-    }
-    fn get_simd_for_ret(&self) -> NEON {
-        NEON::V0
-    }
-
-    fn arch_requires_indirect_call_trampoline(&self) -> bool {
-        self.assembler.arch_requires_indirect_call_trampoline()
-    }
 
     fn arch_emit_indirect_call_with_trampoline(
         &mut self,
@@ -2483,7 +2336,7 @@ impl Machine for MachineARM64 {
             &mut temps,
             ImmType::None,
             true,
-            Some(GPR::X27),
+            Some(self.get_gpr_for_call()),
         )?;
         match loc {
             Location::GPR(reg) => self.assembler.emit_call_register(reg),
@@ -2494,51 +2347,6 @@ impl Machine for MachineARM64 {
         }
         Ok(())
     }
-
-    fn location_address(
-        &mut self,
-        _size: Size,
-        _source: Location,
-        _dest: Location,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_address not implemented")
-    }
-    // logic
-    fn location_and(
-        &mut self,
-        _size: Size,
-        _source: Location,
-        _dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_and not implemented")
-    }
-    fn location_xor(
-        &mut self,
-        _size: Size,
-        _source: Location,
-        _dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_xor not implemented")
-    }
-    fn location_or(
-        &mut self,
-        _size: Size,
-        _source: Location,
-        _dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_or not implemented")
-    }
-    fn location_test(
-        &mut self,
-        _size: Size,
-        _source: Location,
-        _dest: Location,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_test not implemented")
-    }
     // math
     fn location_add(
         &mut self,
@@ -2563,29 +2371,6 @@ impl Machine for MachineARM64 {
         }
         Ok(())
     }
-    fn location_sub(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-        flags: bool,
-    ) -> Result<(), CompileError> {
-        let mut temps = vec![];
-        let src = self.location_to_reg(size, source, &mut temps, ImmType::Bits12, true, None)?;
-        let dst = self.location_to_reg(size, dest, &mut temps, ImmType::None, true, None)?;
-        if flags {
-            self.assembler.emit_subs(size, dst, src, dst)?;
-        } else {
-            self.assembler.emit_sub(size, dst, src, dst)?;
-        }
-        if dst != dest {
-            self.move_location(size, dst, dest)?;
-        }
-        for r in temps {
-            self.release_gpr(r);
-        }
-        Ok(())
-    }
     fn location_cmp(
         &mut self,
         size: Size,
@@ -2594,26 +2379,28 @@ impl Machine for MachineARM64 {
     ) -> Result<(), CompileError> {
         self.emit_relaxed_binop(Assembler::emit_cmp, size, source, dest, false)
     }
-    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError> {
+    fn jmp_unconditional(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_b_label(label)
     }
-    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Eq, label)
-    }
-    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Ne, label)
-    }
-    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Hi, label)
-    }
-    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Cs, label)
-    }
-    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Ls, label)
-    }
-    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_bcond_label_far(Condition::Cs, label)
+
+    fn jmp_on_condition(
+        &mut self,
+        cond: UnsignedCondition,
+        size: Size,
+        loc_a: AbstractLocation<Self::GPR, Self::SIMD>,
+        loc_b: AbstractLocation<Self::GPR, Self::SIMD>,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_cmp, size, loc_b, loc_a, false)?;
+        let cond = match cond {
+            UnsignedCondition::Equal => Condition::Eq,
+            UnsignedCondition::NotEqual => Condition::Ne,
+            UnsignedCondition::Above => Condition::Hi,
+            UnsignedCondition::AboveEqual => Condition::Cs,
+            UnsignedCondition::Below => Condition::Cc,
+            UnsignedCondition::BelowEqual => Condition::Ls,
+        };
+        self.assembler.emit_bcond_label_far(cond, label)
     }
 
     // jmp table
@@ -2661,17 +2448,6 @@ impl Machine for MachineARM64 {
         self.assembler.emit_dmb()
     }
 
-    fn location_neg(
-        &mut self,
-        _size_val: Size, // size of src
-        _signed: bool,
-        _source: Location,
-        _size_op: Size,
-        _dest: Location,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass location_neg unimplemented");
-    }
-
     fn emit_imul_imm32(&mut self, size: Size, imm32: u32, gpr: GPR) -> Result<(), CompileError> {
         let tmp = self.acquire_temp_gpr().ok_or_else(|| {
             CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
@@ -2705,15 +2481,6 @@ impl Machine for MachineARM64 {
     ) -> Result<(), CompileError> {
         self.emit_relaxed_binop(Assembler::emit_cmp, sz, src, dst, false)
     }
-    fn emit_relaxed_zero_extension(
-        &mut self,
-        _sz_src: Size,
-        _src: Location,
-        _sz_dst: Size,
-        _dst: Location,
-    ) -> Result<(), CompileError> {
-        codegen_error!("singlepass emit_relaxed_zero_extension unimplemented");
-    }
     fn emit_relaxed_sign_extension(
         &mut self,
         sz_src: Size,
@@ -2802,7 +2569,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -2869,7 +2635,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -2907,7 +2672,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -4948,7 +4712,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -5015,7 +4778,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -5033,7 +4795,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
@@ -5053,7 +4815,6 @@ impl Machine for MachineARM64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         let mut temps = vec![];
         let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
@@ -5071,7 +4832,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
@@ -7609,7 +7370,6 @@ impl Machine for MachineARM64 {
         heap_access_oob: Label,
         unaligned_atomic: Label,
     ) -> Result<(), CompileError> {
-        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
         self.memory_op(
             target_addr,
             memarg,
@@ -7665,7 +7425,6 @@ impl Machine for MachineARM64 {
         heap_access_oob: Label,
         unaligned_atomic: Label,
     ) -> Result<(), CompileError> {
-        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
         self.memory_op(
             target_addr,
             memarg,
@@ -8536,11 +8295,11 @@ impl Machine for MachineARM64 {
                     ));
                     instructions.push((
                         instruction_offset,
-                        CallFrameInstruction::Offset(dwarf_index(reg2), -(up_to_sp as i32) + 8),
+                        CallFrameInstruction::Offset(reg2.dwarf_index(), -(up_to_sp as i32) + 8),
                     ));
                     instructions.push((
                         instruction_offset,
-                        CallFrameInstruction::Offset(dwarf_index(reg1), -(up_to_sp as i32)),
+                        CallFrameInstruction::Offset(reg1.dwarf_index(), -(up_to_sp as i32)),
                     ));
                 }
                 UnwindOps::DefineNewFrame => {
@@ -8551,8 +8310,9 @@ impl Machine for MachineARM64 {
                 }
                 UnwindOps::SaveRegister { reg, bp_neg_offset } => instructions.push((
                     instruction_offset,
-                    CallFrameInstruction::Offset(dwarf_index(reg), -bp_neg_offset),
+                    CallFrameInstruction::Offset(reg.dwarf_index(), -bp_neg_offset),
                 )),
+                UnwindOps::SubtractFP { .. } => unimplemented!(),
             }
         }
         Some(UnwindInstructions {
diff --git a/lib/compiler-singlepass/src/machine_riscv.rs b/lib/compiler-singlepass/src/machine_riscv.rs
new file mode 100644
index 0000000000..b9f6a2b7aa
--- /dev/null
+++ b/lib/compiler-singlepass/src/machine_riscv.rs
@@ -0,0 +1,6358 @@
+//! RISC-V machine scaffolding.
+
+use dynasmrt::{DynasmError, VecAssembler, riscv::RiscvRelocation};
+#[cfg(feature = "unwind")]
+use gimli::{RiscV, write::CallFrameInstruction};
+
+use wasmer_compiler::{
+    CANONICAL_NAN_F32, CANONICAL_NAN_F64,
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationKind, RelocationTarget},
+        section::CustomSection,
+    },
+    wasmparser::MemArg,
+};
+use wasmer_types::{
+    CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, VMOffsets,
+    target::{CallingConvention, Target},
+};
+
+use crate::{
+    codegen_error,
+    common_decl::*,
+    emitter_riscv::*,
+    location::{Location as AbstractLocation, Reg},
+    machine::*,
+    riscv_decl::{FPR, GPR},
+    unwind::{UnwindInstructions, UnwindOps, UnwindRegister},
+};
+
+type Assembler = VecAssembler<RiscvRelocation>;
+type Location = AbstractLocation<GPR, FPR>;
+
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+};
+/// The RISC-V assembler wrapper, providing FPU feature tracking and a dynasmrt assembler.
+pub struct AssemblerRiscv {
+    /// Inner dynasm assembler.
+    pub inner: Assembler,
+}
+
+impl AssemblerRiscv {
+    /// Create a new RISC-V assembler.
+    pub fn new(base_addr: usize, _target: Option<Target>) -> Result<Self, CompileError> {
+        // TODO: detect RISC-V FPU extensions (e.g., F/D)
+        Ok(Self {
+            inner: Assembler::new(base_addr),
+        })
+    }
+
+    /// Finalize to machine code bytes.
+    pub fn finalize(self) -> Result<Vec<u8>, DynasmError> {
+        self.inner.finalize()
+    }
+}
+
+impl Deref for AssemblerRiscv {
+    type Target = Assembler;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl DerefMut for AssemblerRiscv {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+/// The RISC-V machine state and code emitter.
+pub struct MachineRiscv {
+    assembler: AssemblerRiscv,
+    used_gprs: u32,
+    used_fprs: u32,
+    trap_table: TrapTable,
+    /// Map from byte offset into wasm function to range of native instructions.
+    /// Ordered by increasing InstructionAddressMap::srcloc.
+    instructions_address_map: Vec<InstructionAddressMap>,
+    /// The source location for the current operator.
+    src_loc: u32,
+    /// Vector of unwind operations with offset.
+    unwind_ops: Vec<(usize, UnwindOps<GPR, FPR>)>,
+}
+
+const SCRATCH_REG: GPR = GPR::X28;
+
+impl MachineRiscv {
+    /// Creates a new RISC-V machine for code generation.
+    pub fn new(target: Option<Target>) -> Result<Self, CompileError> {
+        // TODO: for now always require FPU
+        Ok(MachineRiscv {
+            assembler: AssemblerRiscv::new(0, target)?,
+            used_gprs: 0,
+            used_fprs: 0,
+            trap_table: TrapTable::default(),
+            instructions_address_map: vec![],
+            src_loc: 0,
+            unwind_ops: vec![],
+        })
+    }
+
+    fn used_gprs_contains(&self, r: &GPR) -> bool {
+        self.used_gprs & (1 << r.into_index()) != 0
+    }
+    fn used_gprs_insert(&mut self, r: GPR) {
+        self.used_gprs |= 1 << r.into_index();
+    }
+    fn used_gprs_remove(&mut self, r: &GPR) -> bool {
+        let ret = self.used_gprs_contains(r);
+        self.used_gprs &= !(1 << r.into_index());
+        ret
+    }
+
+    fn used_fp_contains(&self, r: &FPR) -> bool {
+        self.used_fprs & (1 << r.into_index()) != 0
+    }
+    fn used_fprs_insert(&mut self, r: FPR) {
+        self.used_fprs |= 1 << r.into_index();
+    }
+    fn used_fprs_remove(&mut self, r: &FPR) -> bool {
+        let ret = self.used_fp_contains(r);
+        self.used_fprs &= !(1 << r.into_index());
+        ret
+    }
+
+    fn location_to_reg(
+        &mut self,
+        sz: Size,
+        src: Location,
+        temps: &mut Vec<GPR>,
+        allow_imm: ImmType,
+        read_val: bool,
+        wanted: Option<GPR>,
+    ) -> Result<Location, CompileError> {
+        match src {
+            Location::GPR(_) | Location::SIMD(_) => Ok(src),
+            Location::Memory(reg, val) => {
+                let tmp = if let Some(wanted) = wanted {
+                    wanted
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    temps.push(tmp);
+                    tmp
+                };
+                if read_val {
+                    if ImmType::Bits12.compatible_imm(val as _) {
+                        self.assembler.emit_ld(sz, false, Location::GPR(tmp), src)?;
+                    } else {
+                        if reg == tmp {
+                            codegen_error!("singlepass reg == tmp unreachable");
+                        }
+                        self.assembler.emit_mov_imm(Location::GPR(tmp), val as _)?;
+                        self.assembler.emit_add(
+                            Size::S64,
+                            Location::GPR(reg),
+                            Location::GPR(tmp),
+                            Location::GPR(tmp),
+                        )?;
+                        self.assembler.emit_ld(
+                            sz,
+                            false,
+                            Location::GPR(tmp),
+                            Location::Memory(tmp, 0),
+                        )?;
+                    }
+                }
+                Ok(Location::GPR(tmp))
+            }
+            _ if src.is_imm() => {
+                let imm = src.imm_value_scalar().unwrap();
+                if imm == 0 {
+                    Ok(Location::GPR(GPR::XZero))
+                } else if allow_imm.compatible_imm(imm) {
+                    Ok(src)
+                } else {
+                    let tmp = if let Some(wanted) = wanted {
+                        wanted
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp);
+                        tmp
+                    };
+                    self.assembler.emit_mov_imm(Location::GPR(tmp), imm as _)?;
+                    Ok(Location::GPR(tmp))
+                }
+            }
+            _ => todo!("unsupported location"),
+        }
+    }
+
+    fn location_to_fpr(
+        &mut self,
+        sz: Size,
+        src: Location,
+        temps: &mut Vec<FPR>,
+        allow_imm: ImmType,
+        read_val: bool,
+    ) -> Result<Location, CompileError> {
+        match src {
+            Location::SIMD(_) => Ok(src),
+            Location::GPR(_) => {
+                let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+                })?;
+                temps.push(tmp);
+                if read_val {
+                    self.assembler.emit_mov(sz, src, Location::SIMD(tmp))?;
+                }
+                Ok(Location::SIMD(tmp))
+            }
+            Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+                })?;
+                temps.push(tmp);
+                if read_val {
+                    self.assembler
+                        .emit_ld(sz, false, Location::SIMD(tmp), src)?;
+                }
+                Ok(Location::SIMD(tmp))
+            }
+            _ if src.is_imm() => {
+                let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+                })?;
+                temps.push(tmp);
+
+                let mut gpr_temps = vec![];
+                let dst =
+                    self.location_to_reg(sz, src, &mut gpr_temps, allow_imm, read_val, None)?;
+                self.assembler.emit_mov(sz, dst, Location::SIMD(tmp))?;
+                for r in gpr_temps {
+                    self.release_gpr(r);
+                }
+
+                Ok(Location::SIMD(tmp))
+            }
+            _ => todo!("unsupported location"),
+        }
+    }
+
+    fn emit_relaxed_binop(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(sz, src, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        op(&mut self.assembler, sz, src, dest)?;
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_binop_fp(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src: Location,
+        dst: Location,
+        putback: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_fpr(sz, src, &mut temps, ImmType::None, true)?;
+        let dest = self.location_to_fpr(sz, dst, &mut temps, ImmType::None, !putback)?;
+        op(&mut self.assembler, sz, src, dest)?;
+        if dst != dest && putback {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_binop3(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+        allow_imm: ImmType,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(sz, src1, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(sz, src2, &mut temps, allow_imm, true, None)?;
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        op(&mut self.assembler, sz, src1, src2, dest)?;
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_atomic_binop3(
+        &mut self,
+        op: AtomicBinaryOp,
+        sz: Size,
+        dst: Location,
+        addr: GPR,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let source = self.location_to_reg(sz, src, &mut temps, ImmType::None, false, None)?;
+        let dest = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::None, false, None)?;
+        let (Location::GPR(source), Location::GPR(dest)) = (source, dest) else {
+            panic!("emit_relaxed_atomic_binop3 expects locations in registers");
+        };
+
+        // RISC-V does not provide atomic operations for binary operations for S8 and S16 types.
+        // And so we must rely on 32-bit atomic operations with a proper masking.
+        match sz {
+            Size::S32 | Size::S64 => {
+                if op == AtomicBinaryOp::Sub {
+                    self.assembler.emit_neg(
+                        Size::S64,
+                        Location::GPR(source),
+                        Location::GPR(source),
+                    )?;
+                    self.assembler.emit_atomic_binop(
+                        AtomicBinaryOp::Add,
+                        sz,
+                        dest,
+                        addr,
+                        source,
+                    )?;
+                } else {
+                    self.assembler
+                        .emit_atomic_binop(op, sz, dest, addr, source)?;
+                }
+                self.assembler.emit_rwfence()?;
+            }
+            Size::S8 | Size::S16 => {
+                let aligned_addr = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(aligned_addr);
+                let bit_offset = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(bit_offset);
+                let bit_mask = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(bit_mask);
+
+                self.assembler.emit_and(
+                    Size::S64,
+                    Location::GPR(addr),
+                    Location::Imm64(-4i64 as _),
+                    Location::GPR(aligned_addr),
+                )?;
+                self.assembler.emit_and(
+                    Size::S64,
+                    Location::GPR(addr),
+                    Location::Imm64(3),
+                    Location::GPR(bit_offset),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(bit_offset),
+                    Location::Imm64(3),
+                    Location::GPR(bit_offset),
+                )?;
+                self.assembler.emit_mov_imm(
+                    Location::GPR(bit_mask),
+                    if sz == Size::S8 {
+                        u8::MAX as _
+                    } else {
+                        u16::MAX as _
+                    },
+                )?;
+                self.assembler.emit_and(
+                    Size::S32,
+                    Location::GPR(source),
+                    Location::GPR(bit_mask),
+                    Location::GPR(source),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(bit_mask),
+                    Location::GPR(bit_offset),
+                    Location::GPR(bit_mask),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(source),
+                    Location::GPR(bit_offset),
+                    Location::GPR(source),
+                )?;
+
+                match op {
+                    AtomicBinaryOp::Add | AtomicBinaryOp::Sub | AtomicBinaryOp::Exchange => {
+                        let loaded_value = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(loaded_value);
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp);
+
+                        // Loop
+                        let label_retry = self.get_label();
+                        self.emit_label(label_retry)?;
+
+                        self.assembler
+                            .emit_reserved_ld(Size::S32, loaded_value, aligned_addr)?;
+
+                        match op {
+                            AtomicBinaryOp::Add => self.assembler.emit_add(
+                                Size::S64,
+                                Location::GPR(loaded_value),
+                                Location::GPR(source),
+                                Location::GPR(tmp),
+                            )?,
+                            AtomicBinaryOp::Sub => self.assembler.emit_sub(
+                                Size::S64,
+                                Location::GPR(loaded_value),
+                                Location::GPR(source),
+                                Location::GPR(tmp),
+                            )?,
+                            AtomicBinaryOp::Exchange => self.assembler.emit_mov(
+                                Size::S64,
+                                Location::GPR(source),
+                                Location::GPR(tmp),
+                            )?,
+                            _ => unreachable!(),
+                        }
+
+                        self.assembler.emit_xor(
+                            Size::S64,
+                            Location::GPR(tmp),
+                            Location::GPR(loaded_value),
+                            Location::GPR(tmp),
+                        )?;
+                        self.assembler.emit_and(
+                            Size::S64,
+                            Location::GPR(tmp),
+                            Location::GPR(bit_mask),
+                            Location::GPR(tmp),
+                        )?;
+                        self.assembler.emit_xor(
+                            Size::S64,
+                            Location::GPR(tmp),
+                            Location::GPR(loaded_value),
+                            Location::GPR(tmp),
+                        )?;
+                        self.assembler
+                            .emit_reserved_sd(Size::S32, tmp, aligned_addr, tmp)?;
+                        let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp2);
+                        self.assembler
+                            .emit_on_true_label(Location::GPR(tmp), label_retry, tmp2)?;
+
+                        self.assembler.emit_rwfence()?;
+
+                        // Return the previous value
+                        self.assembler.emit_and(
+                            Size::S32,
+                            Location::GPR(loaded_value),
+                            Location::GPR(bit_mask),
+                            Location::GPR(dest),
+                        )?;
+                        self.assembler.emit_srl(
+                            Size::S32,
+                            Location::GPR(dest),
+                            Location::GPR(bit_offset),
+                            Location::GPR(dest),
+                        )?;
+                    }
+                    AtomicBinaryOp::Or | AtomicBinaryOp::Xor => {
+                        self.assembler.emit_atomic_binop(
+                            op,
+                            Size::S32,
+                            dest,
+                            aligned_addr,
+                            source,
+                        )?;
+                        self.assembler.emit_rwfence()?;
+                        self.assembler.emit_and(
+                            Size::S32,
+                            Location::GPR(dest),
+                            Location::GPR(bit_mask),
+                            Location::GPR(dest),
+                        )?;
+                        self.assembler.emit_srl(
+                            Size::S32,
+                            Location::GPR(dest),
+                            Location::GPR(bit_offset),
+                            Location::GPR(dest),
+                        )?;
+                    }
+                    AtomicBinaryOp::And => {
+                        self.assembler.emit_not(
+                            Size::S64,
+                            Location::GPR(bit_mask),
+                            Location::GPR(bit_mask),
+                        )?;
+                        self.assembler.emit_or(
+                            Size::S64,
+                            Location::GPR(bit_mask),
+                            Location::GPR(source),
+                            Location::GPR(source),
+                        )?;
+                        self.assembler.emit_not(
+                            Size::S64,
+                            Location::GPR(bit_mask),
+                            Location::GPR(bit_mask),
+                        )?;
+                        self.assembler.emit_atomic_binop(
+                            op,
+                            Size::S32,
+                            dest,
+                            aligned_addr,
+                            source,
+                        )?;
+                        self.assembler.emit_rwfence()?;
+                        self.assembler.emit_and(
+                            Size::S32,
+                            Location::GPR(dest),
+                            Location::GPR(bit_mask),
+                            Location::GPR(dest),
+                        )?;
+                        self.assembler.emit_srl(
+                            Size::S32,
+                            Location::GPR(dest),
+                            Location::GPR(bit_offset),
+                            Location::GPR(dest),
+                        )?;
+                    }
+                }
+            }
+        }
+
+        if dst != Location::GPR(dest) {
+            self.move_location(sz, Location::GPR(dest), dst)?;
+        }
+
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_atomic_cmpxchg(
+        &mut self,
+        size: Size,
+        dst: Location,
+        addr: GPR,
+        new: Location,
+        cmp: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let cmp = self.location_to_reg(size, cmp, &mut temps, ImmType::None, true, None)?;
+        let new = self.location_to_reg(size, new, &mut temps, ImmType::None, true, None)?;
+        let (Location::GPR(cmp), Location::GPR(new)) = (cmp, new) else {
+            panic!("emit_relaxed_atomic_cmpxchg expects locations in registers");
+        };
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        match size {
+            Size::S32 | Size::S64 => {
+                let value = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(value);
+                let cond = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(cond);
+
+                // main re-try loop
+                let label_retry = self.get_label();
+                let label_after_retry = self.get_label();
+                self.emit_label(label_retry)?;
+
+                self.assembler.emit_reserved_ld(size, value, addr)?;
+                self.assembler.emit_cmp(
+                    Condition::Eq,
+                    Location::GPR(value),
+                    Location::GPR(cmp),
+                    Location::GPR(cond),
+                )?;
+                self.assembler.emit_on_false_label(
+                    Location::GPR(cond),
+                    label_after_retry,
+                    jmp_tmp,
+                )?;
+                self.assembler.emit_reserved_sd(size, cond, addr, new)?;
+                self.assembler
+                    .emit_on_true_label(Location::GPR(cond), label_retry, jmp_tmp)?;
+
+                // after re-try get the previous value
+                self.assembler.emit_rwfence()?;
+                self.emit_label(label_after_retry)?;
+
+                self.assembler.emit_mov(size, Location::GPR(value), dst)?;
+            }
+            Size::S8 | Size::S16 => {
+                let value = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(value);
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(tmp);
+                let bit_offset = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(bit_offset);
+                let bit_mask = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(bit_mask);
+                let cond = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(cond);
+
+                // before the loop
+                self.assembler.emit_and(
+                    Size::S64,
+                    Location::GPR(addr),
+                    Location::Imm64(3),
+                    Location::GPR(bit_offset),
+                )?;
+                self.assembler.emit_and(
+                    Size::S64,
+                    Location::GPR(addr),
+                    Location::Imm64(-4i64 as _),
+                    Location::GPR(addr),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(bit_offset),
+                    Location::Imm64(3),
+                    Location::GPR(bit_offset),
+                )?;
+                self.assembler.emit_mov_imm(
+                    Location::GPR(bit_mask),
+                    if size == Size::S8 {
+                        u8::MAX as _
+                    } else {
+                        u16::MAX as _
+                    },
+                )?;
+                self.assembler.emit_and(
+                    Size::S32,
+                    Location::GPR(new),
+                    Location::GPR(bit_mask),
+                    Location::GPR(new),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(bit_mask),
+                    Location::GPR(bit_offset),
+                    Location::GPR(bit_mask),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(new),
+                    Location::GPR(bit_offset),
+                    Location::GPR(new),
+                )?;
+                self.assembler.emit_sll(
+                    Size::S64,
+                    Location::GPR(cmp),
+                    Location::GPR(bit_offset),
+                    Location::GPR(cmp),
+                )?;
+
+                // main re-try loop
+                let label_retry = self.get_label();
+                let label_after_retry = self.get_label();
+                self.emit_label(label_retry)?;
+
+                self.assembler.emit_reserved_ld(Size::S32, value, addr)?;
+                self.assembler.emit_and(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::GPR(bit_mask),
+                    Location::GPR(tmp),
+                )?;
+
+                self.assembler.emit_cmp(
+                    Condition::Eq,
+                    Location::GPR(tmp),
+                    Location::GPR(cmp),
+                    Location::GPR(cond),
+                )?;
+                self.assembler.emit_on_false_label(
+                    Location::GPR(cond),
+                    label_after_retry,
+                    jmp_tmp,
+                )?;
+
+                // mask new to the 4B word
+                self.assembler.emit_xor(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::GPR(new),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler.emit_and(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    Location::GPR(bit_mask),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler.emit_xor(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    Location::GPR(value),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler
+                    .emit_reserved_sd(Size::S32, cond, addr, tmp)?;
+                self.assembler
+                    .emit_on_true_label(Location::GPR(cond), label_retry, jmp_tmp)?;
+
+                // After re-try get the previous value
+                self.assembler.emit_rwfence()?;
+                self.emit_label(label_after_retry)?;
+
+                self.assembler.emit_and(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::GPR(bit_mask),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler.emit_srl(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    Location::GPR(bit_offset),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler
+                    .emit_mov(Size::S32, Location::GPR(tmp), dst)?;
+            }
+        }
+
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn emit_relaxed_binop3_fp(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+        allow_imm: ImmType,
+        return_nan_if_present: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let mut gprs = vec![];
+        let src1 = self.location_to_fpr(sz, src1, &mut temps, ImmType::None, true)?;
+        let src2 = self.location_to_fpr(sz, src2, &mut temps, allow_imm, true)?;
+        let dest = self.location_to_fpr(sz, dst, &mut temps, ImmType::None, false)?;
+
+        let label_after = self.get_label();
+        if return_nan_if_present {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            gprs.push(tmp);
+            let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            gprs.push(jmp_tmp);
+
+            // Return an ArithmeticNan if either src1 or (and) src2 have a NaN value.
+            let canonical_nan = match sz {
+                Size::S32 => CANONICAL_NAN_F32 as u64,
+                Size::S64 => CANONICAL_NAN_F64,
+                _ => unreachable!(),
+            };
+
+            self.assembler
+                .emit_mov_imm(Location::GPR(tmp), canonical_nan as _)?;
+            self.assembler.emit_mov(sz, Location::GPR(tmp), dest)?;
+
+            self.assembler
+                .emit_fcmp(Condition::Eq, sz, src1, src1, Location::GPR(tmp))?;
+            self.assembler
+                .emit_on_false_label(Location::GPR(tmp), label_after, jmp_tmp)?;
+
+            self.assembler
+                .emit_fcmp(Condition::Eq, sz, src2, src2, Location::GPR(tmp))?;
+            self.assembler
+                .emit_on_false_label(Location::GPR(tmp), label_after, jmp_tmp)?;
+        }
+
+        op(&mut self.assembler, sz, src1, src2, dest)?;
+        self.emit_label(label_after)?;
+
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_simd(r);
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_cmp(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        sz: Size,
+        signed: bool,
+    ) -> Result<(), CompileError> {
+        // TODO: add support for immediate operations where some instructions (like `slti`) can be used
+        let mut temps = vec![];
+        let loc_a = self.location_to_reg(sz, loc_a, &mut temps, ImmType::None, true, None)?;
+        let loc_b = self.location_to_reg(sz, loc_b, &mut temps, ImmType::None, true, None)?;
+
+        if sz != Size::S64 {
+            self.assembler.emit_extend(sz, signed, loc_a, loc_a)?;
+            self.assembler.emit_extend(sz, signed, loc_b, loc_b)?;
+        }
+
+        let dest = self.location_to_reg(sz, ret, &mut temps, ImmType::None, false, None)?;
+        self.assembler.emit_cmp(c, loc_a, loc_b, dest)?;
+        if ret != dest {
+            self.move_location(sz, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    /// I32 comparison with.
+    fn emit_cmpop_i32_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        signed: bool,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_cmp(c, loc_a, loc_b, ret, Size::S32, signed)
+    }
+
+    /// I64 comparison with.
+    fn emit_cmpop_i64_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_cmp(c, loc_a, loc_b, ret, Size::S64, false)
+    }
+
+    /// NOTE: As observed on the VisionFive 2 board, when an unaligned memory write happens to write out of bounds (and thus triggers SIGSEGV),
+    /// the memory is partially modified and observable for a subsequent memory read operations.
+    /// Thus, we always check the boundaries.
+    #[allow(clippy::too_many_arguments)]
+    fn memory_op<F: FnOnce(&mut Self, GPR) -> Result<(), CompileError>>(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        check_alignment: bool,
+        value_size: usize,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+        cb: F,
+    ) -> Result<(), CompileError> {
+        let value_size = value_size as i64;
+        let tmp_addr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Reusing `tmp_addr` for temporary indirection here, since it's not used before the last reference to `{base,bound}_loc`.
+        let (base_loc, bound_loc) = if imported_memories {
+            // Imported memories require one level of indirection.
+            self.emit_relaxed_binop(
+                Assembler::emit_mov,
+                Size::S64,
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::GPR(tmp_addr),
+            )?;
+            (Location::Memory(tmp_addr, 0), Location::Memory(tmp_addr, 8))
+        } else {
+            (
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::Memory(self.get_vmctx_reg(), offset + 8),
+            )
+        };
+
+        let tmp_base = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_bound = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Load base into temporary register.
+        self.emit_relaxed_load(Size::S64, false, Location::GPR(tmp_base), base_loc)?;
+
+        // Load bound into temporary register.
+        self.emit_relaxed_load(Size::S64, false, Location::GPR(tmp_bound), bound_loc)?;
+
+        // Wasm -> Effective.
+        // Assuming we never underflow - should always be true on Linux/macOS and Windows >=8,
+        // since the first page from 0x0 to 0x1000 is not accepted by mmap.
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(tmp_bound),
+            Location::GPR(tmp_base),
+            Location::GPR(tmp_bound),
+        )?;
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::GPR(tmp_bound),
+            Location::Imm64(value_size as _),
+            Location::GPR(tmp_bound),
+        )?;
+
+        // Load effective address.
+        // `base_loc` and `bound_loc` becomes INVALID after this line, because `tmp_addr`
+        // might be reused.
+        self.move_location(Size::S32, addr, Location::GPR(tmp_addr))?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Add offset to memory address.
+        if memarg.offset != 0 {
+            if ImmType::Bits12.compatible_imm(memarg.offset as _) {
+                self.assembler.emit_add(
+                    Size::S64,
+                    Location::Imm64(memarg.offset),
+                    Location::GPR(tmp_addr),
+                    Location::GPR(tmp_addr),
+                )?;
+            } else {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.assembler
+                    .emit_mov_imm(Location::GPR(tmp), memarg.offset as _)?;
+                self.assembler.emit_add(
+                    Size::S64,
+                    Location::GPR(tmp_addr),
+                    Location::GPR(tmp),
+                    Location::GPR(tmp_addr),
+                )?;
+                self.release_gpr(tmp);
+            }
+
+            // Trap if offset calculation overflowed in 32-bits by checking
+            // the upper half of the 64-bit register.
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.assembler.emit_srl(
+                Size::S64,
+                Location::GPR(tmp_addr),
+                Location::Imm64(32),
+                Location::GPR(tmp),
+            )?;
+            self.assembler
+                .emit_on_true_label_far(Location::GPR(tmp), heap_access_oob, jmp_tmp)?;
+            self.release_gpr(tmp);
+        }
+
+        // Wasm linear memory -> real memory
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(tmp_base),
+            Location::GPR(tmp_addr),
+            Location::GPR(tmp_addr),
+        )?;
+
+        // tmp_base is already unused
+        let cond = tmp_base;
+
+        // Trap if the end address of the requested area is above that of the linear memory.
+        self.assembler.emit_cmp(
+            Condition::Le,
+            Location::GPR(tmp_addr),
+            Location::GPR(tmp_bound),
+            Location::GPR(cond),
+        )?;
+
+        // `tmp_bound` is inclusive. So trap only if `tmp_addr > tmp_bound`.
+        self.assembler
+            .emit_on_false_label_far(Location::GPR(cond), heap_access_oob, jmp_tmp)?;
+
+        self.release_gpr(tmp_bound);
+        self.release_gpr(cond);
+
+        let align = value_size as u32;
+        if check_alignment && align != 1 {
+            self.assembler.emit_and(
+                Size::S64,
+                Location::GPR(tmp_addr),
+                Location::Imm64((align - 1) as u64),
+                Location::GPR(cond),
+            )?;
+            self.assembler.emit_on_true_label_far(
+                Location::GPR(cond),
+                unaligned_atomic,
+                jmp_tmp,
+            )?;
+        }
+        let begin = self.assembler.get_offset().0;
+        cb(self, tmp_addr)?;
+        let end = self.assembler.get_offset().0;
+        self.mark_address_range_with_trap_code(TrapCode::HeapAccessOutOfBounds, begin, end);
+
+        self.release_gpr(jmp_tmp);
+        self.release_gpr(tmp_addr);
+        Ok(())
+    }
+
+    fn emit_relaxed_load(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if ImmType::Bits12.compatible_imm(offset as i64) {
+                    self.assembler.emit_ld(sz, signed, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), offset as i64)?;
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(addr),
+                        Location::GPR(tmp),
+                        Location::GPR(tmp),
+                    )?;
+                    self.assembler
+                        .emit_ld(sz, signed, dest, Location::Memory(tmp, 0))?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_load unreachable"),
+        }
+        if dst != dest {
+            // Memory location is used for a local, save the entire register!
+            self.move_location(Size::S64, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_maybe_unaligned_load(
+        &mut self,
+        sz: Size,
+        signed: bool,
+        dst: Location,
+        src: GPR,
+    ) -> Result<(), CompileError> {
+        if let Size::S8 = sz {
+            return self.emit_relaxed_load(sz, signed, dst, Location::Memory(src, 0));
+        }
+
+        let label_unaligned = self.get_label();
+        let label_completed = self.get_label();
+        let mut temps = vec![];
+        let tmp_cond = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(tmp_cond);
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(src),
+            Location::Imm64((sz.bytes() - 1) as u64),
+            Location::GPR(tmp_cond),
+        )?;
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+        self.assembler
+            .emit_on_true_label(Location::GPR(tmp_cond), label_unaligned, jmp_tmp)?;
+        // Aligned load
+        self.assembler
+            .emit_ld(sz, signed, dest, Location::Memory(src, 0))?;
+        self.jmp_unconditional(label_completed)?;
+        self.emit_label(label_unaligned)?;
+
+        // Unaligned load
+        let tmp_value = tmp_cond;
+
+        // We assume little-endian for now
+        self.assembler
+            .emit_ld(Size::S8, false, dest, Location::Memory(src, 0))?;
+        for i in 1..sz.bytes() {
+            self.assembler.emit_ld(
+                Size::S8,
+                if i == sz.bytes() - 1 { signed } else { false },
+                Location::GPR(tmp_value),
+                Location::Memory(src, i as _),
+            )?;
+            self.assembler.emit_sll(
+                Size::S64,
+                Location::GPR(tmp_value),
+                Location::Imm64(8 * i as u64),
+                Location::GPR(tmp_value),
+            )?;
+            self.assembler
+                .emit_or(Size::S64, dest, Location::GPR(tmp_value), dest)?;
+        }
+
+        // Load completed
+        self.emit_label(label_completed)?;
+        if dst != dest {
+            // Memory location is used for a local, save the entire register!
+            self.move_location(Size::S64, dest, dst)?;
+        }
+
+        for tmp in temps {
+            self.release_gpr(tmp);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_store(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::None, true, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if ImmType::Bits12.compatible_imm(offset as i64) {
+                    self.assembler.emit_sd(sz, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), offset as i64)?;
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(addr),
+                        Location::GPR(tmp),
+                        Location::GPR(tmp),
+                    )?;
+                    self.assembler.emit_sd(sz, dest, Location::Memory(tmp, 0))?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_store unreachable"),
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_maybe_unaligned_store(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: GPR,
+    ) -> Result<(), CompileError> {
+        if let Size::S8 = sz {
+            // `emit_relaxed_store` uses wrong order of src and dst.
+            // The `src` parameter of `emit_relaxed_store` actually stores
+            // the destination address, while the `dst` parameter of
+            // `emit_relaxed_store` actually contains the source register.
+            return self.emit_relaxed_store(sz, src, Location::Memory(dst, 0));
+        }
+
+        let label_unaligned = self.get_label();
+        let label_completed = self.get_label();
+        let mut temps = vec![];
+        let tmp_cond = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(tmp_cond);
+        let src_value =
+            self.location_to_reg(Size::S64, src, &mut temps, ImmType::None, true, None)?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(dst),
+            Location::Imm64((sz.bytes() - 1) as u64),
+            Location::GPR(tmp_cond),
+        )?;
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+        self.assembler
+            .emit_on_true_label(Location::GPR(tmp_cond), label_unaligned, jmp_tmp)?;
+        // Aligned store
+        self.assembler
+            .emit_sd(sz, src_value, Location::Memory(dst, 0))?;
+        self.jmp_unconditional(label_completed)?;
+        self.emit_label(label_unaligned)?;
+
+        // Unaligned store
+        let size_bytes = sz.bytes();
+        // We assume little-endian for now
+        for i in 0..size_bytes {
+            self.assembler
+                .emit_sd(Size::S8, src_value, Location::Memory(dst, i as _))?;
+            if i != size_bytes - 1 {
+                self.assembler
+                    .emit_srl(Size::S64, src_value, Location::Imm64(8), src_value)?;
+            }
+        }
+
+        // Store completed
+        self.emit_label(label_completed)?;
+
+        for tmp in temps {
+            self.release_gpr(tmp);
+        }
+        Ok(())
+    }
+
+    fn emit_rol(
+        &mut self,
+        sz: Size,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        allow_imm: ImmType,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let size_bits = sz.bits();
+
+        let src2 = if let Some(imm) = loc_b.imm_value_scalar() {
+            Location::Imm32(size_bits - (imm as u32) % size_bits)
+        } else {
+            let tmp1 = self.location_to_reg(
+                sz,
+                Location::Imm32(size_bits),
+                &mut temps,
+                ImmType::None,
+                true,
+                None,
+            )?;
+            let tmp2 = self.location_to_reg(sz, loc_b, &mut temps, ImmType::None, true, None)?;
+            self.assembler.emit_sub(sz, tmp1, tmp2, tmp1)?;
+            tmp1
+        };
+
+        self.emit_ror(sz, loc_a, src2, ret, allow_imm)?;
+
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_ror(
+        &mut self,
+        sz: Size,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        allow_imm: ImmType,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+
+        let imm = match sz {
+            Size::S32 | Size::S64 => Location::Imm32(sz.bits() as u32),
+            _ => codegen_error!("singlepass emit_ror unreachable"),
+        };
+        let imm = self.location_to_reg(sz, imm, &mut temps, ImmType::None, false, None)?;
+
+        let tmp1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.emit_relaxed_binop3(
+            Assembler::emit_srl,
+            sz,
+            loc_a,
+            loc_b,
+            Location::GPR(tmp1),
+            allow_imm,
+        )?;
+
+        let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.emit_relaxed_binop3(
+            Assembler::emit_sub,
+            sz,
+            imm,
+            loc_b,
+            Location::GPR(tmp2),
+            allow_imm,
+        )?;
+        self.emit_relaxed_binop3(
+            Assembler::emit_sll,
+            sz,
+            loc_a,
+            Location::GPR(tmp2),
+            Location::GPR(tmp2),
+            ImmType::Bits12,
+        )?;
+        self.assembler.emit_or(
+            sz,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp1),
+        )?;
+
+        self.move_location(sz, Location::GPR(tmp1), ret)?;
+        self.release_gpr(tmp1);
+        self.release_gpr(tmp2);
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_popcnt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        let arg = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let cnt = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let temp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(sz, src, Location::GPR(arg))?;
+
+        self.move_location(sz, Location::Imm32(0), Location::GPR(cnt))?;
+        let one_imm = match sz {
+            Size::S32 => Location::Imm32(1),
+            Size::S64 => Location::Imm64(1),
+            _ => codegen_error!("singlepass emit_popcnt unreachable"),
+        };
+
+        let label_loop = self.assembler.get_label();
+        let label_exit = self.assembler.get_label();
+
+        self.assembler.emit_label(label_loop)?; // loop:
+        self.assembler
+            .emit_and(sz, Location::GPR(arg), one_imm, Location::GPR(temp))?;
+        self.assembler.emit_add(
+            sz,
+            Location::GPR(cnt),
+            Location::GPR(temp),
+            Location::GPR(cnt),
+        )?;
+        self.assembler
+            .emit_srl(sz, Location::GPR(arg), one_imm, Location::GPR(arg))?;
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(arg), label_exit, jmp_tmp)?;
+        self.release_gpr(jmp_tmp);
+        self.jmp_unconditional(label_loop)?;
+
+        self.assembler.emit_label(label_exit)?; // exit:
+
+        self.move_location(sz, Location::GPR(cnt), dst)?;
+
+        self.release_gpr(arg);
+        self.release_gpr(cnt);
+        self.release_gpr(temp);
+        Ok(())
+    }
+
+    fn emit_ctz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        let size_bits = sz.bits();
+        let arg = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let cnt = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let temp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(sz, src, Location::GPR(arg))?;
+
+        let one_imm = match sz {
+            Size::S32 => Location::Imm32(1),
+            Size::S64 => Location::Imm64(1),
+            _ => codegen_error!("singlepass emit_ctz unreachable"),
+        };
+
+        let label_loop = self.assembler.get_label();
+        let label_exit = self.assembler.get_label();
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // if the value is zero, return size_bits
+        self.move_location(sz, Location::Imm32(size_bits), Location::GPR(cnt))?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(arg), label_exit, jmp_tmp)?;
+
+        self.move_location(sz, Location::Imm32(0), Location::GPR(cnt))?;
+
+        self.assembler.emit_label(label_loop)?; // loop:
+        self.assembler
+            .emit_and(sz, Location::GPR(arg), one_imm, Location::GPR(temp))?;
+        self.assembler
+            .emit_on_true_label(Location::GPR(temp), label_exit, jmp_tmp)?;
+
+        self.release_gpr(jmp_tmp);
+
+        self.assembler
+            .emit_add(sz, Location::GPR(cnt), one_imm, Location::GPR(cnt))?;
+        self.assembler
+            .emit_srl(sz, Location::GPR(arg), one_imm, Location::GPR(arg))?;
+        self.jmp_unconditional(label_loop)?;
+
+        self.assembler.emit_label(label_exit)?; // exit:
+
+        self.move_location(sz, Location::GPR(cnt), dst)?;
+
+        self.release_gpr(arg);
+        self.release_gpr(cnt);
+        self.release_gpr(temp);
+        Ok(())
+    }
+
+    fn emit_clz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        let size_bits = sz.bits();
+        let arg = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let cnt = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(sz, src, Location::GPR(arg))?;
+
+        let one_imm = match sz {
+            Size::S32 => Location::Imm32(1),
+            Size::S64 => Location::Imm64(1),
+            _ => codegen_error!("singlepass emit_ctz unreachable"),
+        };
+
+        let label_loop = self.assembler.get_label();
+        let label_exit = self.assembler.get_label();
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // if the value is zero, return size_bits
+        self.move_location(sz, Location::Imm32(size_bits), Location::GPR(cnt))?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(arg), label_exit, jmp_tmp)?;
+
+        self.move_location(sz, Location::Imm32(0), Location::GPR(cnt))?;
+
+        // loop:
+        self.assembler.emit_label(label_loop)?;
+        // Shift the argument by (bit_size - cnt - 1) and test if it's one
+        self.move_location(
+            Size::S32,
+            Location::Imm32(size_bits - 1),
+            Location::GPR(tmp),
+        )?;
+        self.assembler.emit_sub(
+            Size::S32,
+            Location::GPR(tmp),
+            Location::GPR(cnt),
+            Location::GPR(tmp),
+        )?;
+        self.assembler.emit_srl(
+            sz,
+            Location::GPR(arg),
+            Location::GPR(tmp),
+            Location::GPR(tmp),
+        )?;
+        self.assembler
+            .emit_on_true_label(Location::GPR(tmp), label_exit, jmp_tmp)?;
+
+        self.assembler
+            .emit_add(sz, Location::GPR(cnt), one_imm, Location::GPR(cnt))?;
+        self.release_gpr(jmp_tmp);
+        self.jmp_unconditional(label_loop)?;
+
+        self.assembler.emit_label(label_exit)?; // exit:i
+
+        self.move_location(sz, Location::GPR(cnt), dst)?;
+
+        self.release_gpr(arg);
+        self.release_gpr(cnt);
+        self.release_gpr(tmp);
+        Ok(())
+    }
+
+    fn convert_float_to_int(
+        &mut self,
+        loc: Location,
+        size_in: Size,
+        ret: Location,
+        size_out: Size,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut fprs = vec![];
+        let src = self.location_to_fpr(size_in, loc, &mut fprs, ImmType::None, true)?;
+        let dest = self.location_to_reg(size_out, ret, &mut gprs, ImmType::None, false, None)?;
+
+        if sat {
+            // On RISC-V, if the input value is any NaN, the output of the operation is i32::MAX and thus we must
+            // convert it to zero on our own.
+            let end = self.assembler.get_label();
+            let cond = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.zero_location(size_out, dest)?;
+            // if NaN -> skip convert operation
+            self.assembler
+                .emit_fcmp(Condition::Eq, size_in, src, src, Location::GPR(cond))?;
+            let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.assembler
+                .emit_on_false_label(Location::GPR(cond), end, jmp_tmp)?;
+            self.release_gpr(jmp_tmp);
+            self.release_gpr(cond);
+
+            self.assembler
+                .emit_fcvt(signed, size_in, src, size_out, dest)?;
+            self.emit_label(end)?;
+        } else {
+            let old_fcsr = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.move_location(
+                Size::S32,
+                Location::GPR(GPR::XZero),
+                Location::GPR(old_fcsr),
+            )?;
+            self.assembler.emit_swap_fscr(old_fcsr)?;
+            self.assembler
+                .emit_fcvt(signed, size_in, src, size_out, dest)?;
+            self.trap_float_convertion_errors(size_in, src, old_fcsr, &mut gprs)?;
+            self.release_gpr(old_fcsr);
+        }
+
+        if ret != dest {
+            self.move_location(size_out, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in fprs {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+
+    fn convert_int_to_float(
+        &mut self,
+        loc: Location,
+        size_in: Size,
+        ret: Location,
+        size_out: Size,
+        signed: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut fprs = vec![];
+        let src = self.location_to_reg(size_in, loc, &mut gprs, ImmType::None, true, None)?;
+        let dest = self.location_to_fpr(size_out, ret, &mut fprs, ImmType::None, false)?;
+        self.assembler
+            .emit_fcvt(signed, size_in, src, size_out, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in fprs {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+
+    fn convert_float_to_float(
+        &mut self,
+        loc: Location,
+        size_in: Size,
+        ret: Location,
+        size_out: Size,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_fpr(size_in, loc, &mut temps, ImmType::None, true)?;
+        let dest = self.location_to_fpr(size_out, ret, &mut temps, ImmType::None, false)?;
+
+        match (size_in, size_out) {
+            (Size::S32, Size::S64) => self
+                .assembler
+                .emit_fcvt(false, size_in, src, size_out, dest)?,
+            (Size::S64, Size::S32) => self
+                .assembler
+                .emit_fcvt(false, size_in, src, size_out, dest)?,
+            _ => codegen_error!("singlepass convert_float_to_float unreachable"),
+        }
+
+        if ret != dest {
+            self.move_location(size_out, dest, ret)?;
+        }
+        for r in temps {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+
+    fn trap_float_convertion_errors(
+        &mut self,
+        sz: Size,
+        f: Location,
+        old_fcsr: GPR,
+        temps: &mut Vec<GPR>,
+    ) -> Result<(), CompileError> {
+        let fscr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.zero_location(Size::S64, Location::GPR(fscr))?;
+        temps.push(fscr);
+
+        let trap_badconv = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.assembler.emit_swap_fscr(fscr)?;
+
+        // The documentation link connected to the behavior connected to FCSR register: https://five-embeddev.com/riscv-user-isa-manual/Priv-v1.12/f.html.
+        // clear all fflags bits except NV (1 << 4)
+        self.assembler.emit_srl(
+            Size::S32,
+            Location::GPR(fscr),
+            Location::Imm32(4),
+            Location::GPR(fscr),
+        )?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label(Location::GPR(fscr), end, jmp_tmp)?;
+
+        // now need to check if it's overflow or NaN
+        let cond = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(cond);
+
+        self.assembler
+            .emit_fcmp(Condition::Eq, sz, f, f, Location::GPR(cond))?;
+        // fallthru: trap_overflow
+        self.assembler
+            .emit_on_false_label(Location::GPR(cond), trap_badconv, jmp_tmp)?;
+        self.emit_illegal_op_internal(TrapCode::IntegerOverflow)?;
+        self.emit_label(trap_badconv)?;
+        self.emit_illegal_op_internal(TrapCode::BadConversionToInteger)?;
+
+        self.emit_label(end)?;
+        self.assembler.emit_swap_fscr(old_fcsr)?;
+
+        Ok(())
+    }
+
+    fn emit_illegal_op_internal(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        self.assembler.emit_udf(trap as u8)
+    }
+
+    fn emit_relaxed_fcmp(
+        &mut self,
+        c: Condition,
+        size: Size,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        // TODO: add support for immediate operations
+        let mut fprs = vec![];
+        let mut gprs = vec![];
+
+        let loc_a = self.location_to_fpr(size, loc_a, &mut fprs, ImmType::None, true)?;
+        let loc_b = self.location_to_fpr(size, loc_b, &mut fprs, ImmType::None, true)?;
+        let dest = self.location_to_reg(size, ret, &mut gprs, ImmType::None, false, None)?;
+
+        self.assembler.emit_fcmp(c, size, loc_a, loc_b, dest)?;
+        if ret != dest {
+            self.move_location(size, dest, ret)?;
+        }
+        for r in fprs {
+            self.release_simd(r);
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_fcvt_with_rounding(
+        &mut self,
+        rounding: RoundingMode,
+        size: Size,
+        loc: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        // For f64, values ≥ 2^52, the least significant bit of the significand represents 2,
+        // so you can't represent odd integers or any fractional part.
+        // Similarly, for f32, values ≥ 2^24 fulfil the same precondition.
+
+        let mut fprs = vec![];
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        let loc = self.location_to_fpr(size, loc, &mut fprs, ImmType::None, true)?;
+        let dest = self.location_to_fpr(size, ret, &mut fprs, ImmType::None, false)?;
+
+        let cond = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+        })?;
+
+        let label_after = self.get_label();
+
+        // Return an ArithmeticNan if either src1 or (and) src2 have a NaN value.
+        let canonical_nan = match size {
+            Size::S32 => CANONICAL_NAN_F32 as u64,
+            Size::S64 => CANONICAL_NAN_F64,
+            _ => unreachable!(),
+        };
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp fpr".to_owned())
+        })?;
+
+        self.assembler
+            .emit_mov_imm(Location::GPR(tmp), canonical_nan as _)?;
+        self.assembler.emit_mov(size, Location::GPR(tmp), dest)?;
+        self.assembler
+            .emit_fcmp(Condition::Eq, size, loc, loc, Location::GPR(cond))?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(cond), label_after, jmp_tmp)?;
+
+        // TODO: refactor the constants
+        if size == Size::S64 {
+            self.assembler
+                .emit_mov_imm(Location::GPR(cond), 0x4330000000000000)?;
+            self.assembler
+                .emit_mov(Size::S64, Location::GPR(cond), Location::SIMD(tmp1))?;
+            self.f64_abs(loc, Location::SIMD(tmp2))?;
+        } else {
+            assert!(size == Size::S32);
+            self.assembler
+                .emit_mov_imm(Location::GPR(cond), 0x4b000000)?;
+            self.assembler
+                .emit_mov(Size::S32, Location::GPR(cond), Location::SIMD(tmp1))?;
+            self.f32_abs(loc, Location::SIMD(tmp2))?;
+        }
+        self.emit_relaxed_fcmp(
+            Condition::Lt,
+            size,
+            Location::SIMD(tmp2),
+            Location::SIMD(tmp1),
+            Location::GPR(cond),
+        )?;
+
+        self.assembler.emit_mov(size, loc, dest)?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(cond), label_after, jmp_tmp)?;
+
+        // Emit the actual conversion operation.
+        self.assembler
+            .emit_fcvt_with_rounding(rounding, size, loc, dest, cond)?;
+        self.emit_label(label_after)?;
+
+        if ret != dest {
+            self.move_location(size, dest, ret)?;
+        }
+
+        for r in fprs {
+            self.release_simd(r);
+        }
+        self.release_gpr(jmp_tmp);
+        self.release_gpr(tmp);
+        self.release_gpr(cond);
+        self.release_simd(tmp1);
+        self.release_simd(tmp2);
+        Ok(())
+    }
+
+    fn emit_unwind_op(&mut self, op: UnwindOps<GPR, FPR>) {
+        self.unwind_ops.push((self.get_offset().0, op));
+    }
+}
+
+/// Get registers for first N function return values.
+/// NOTE: The register set must be disjoint from pick_gpr registers!
+/// Intentionally omit GPR::X17: it is reserved as a scratch/temporary register
+/// and is frequently used while materializing/storing return values.
+pub(crate) const RISCV_RETURN_VALUE_REGISTERS: [GPR; 7] = [
+    GPR::X10,
+    GPR::X11,
+    GPR::X12,
+    GPR::X13,
+    GPR::X14,
+    GPR::X15,
+    GPR::X16,
+];
+
+#[allow(dead_code)]
+#[derive(PartialEq, Copy, Clone)]
+pub(crate) enum ImmType {
+    None,
+    Bits12,
+    // `add(w) X(rd) -imm` is used for subtraction with an immediate, so we need to check
+    // the range of negated value.
+    Bits12Subtraction,
+    Shift32,
+    Shift64,
+}
+
+impl ImmType {
+    pub(crate) fn compatible_imm(&self, imm: i64) -> bool {
+        match self {
+            ImmType::None => false,
+            ImmType::Bits12 => (-0x800..0x800).contains(&imm),
+            ImmType::Bits12Subtraction => (-0x801..0x801).contains(&imm),
+            ImmType::Shift32 => (0..32).contains(&imm),
+            ImmType::Shift64 => (0..64).contains(&imm),
+        }
+    }
+}
+
+impl Machine for MachineRiscv {
+    type GPR = GPR;
+    type SIMD = FPR;
+    fn assembler_get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+    fn get_vmctx_reg(&self) -> Self::GPR {
+        // Must be a callee-save register.
+        GPR::X27
+    }
+    fn pick_gpr(&self) -> Option<Self::GPR> {
+        use GPR::*;
+        // Ignore X28 as we use it as a scratch register
+        static REGS: &[GPR] = &[X5, X6, X7, X29, X30, X31];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused general purpose register for internal temporary use.
+    fn pick_temp_gpr(&self) -> Option<GPR> {
+        use GPR::*;
+        // Reserve a few registers for the first locals of a function!
+        // These registers below are also used for argument passing, so they must
+        // be saved/moved in the function prologue before being used as temps.
+        static REGS: &[GPR] = &[X17, X16, X15, X14, X13, X12, X11, X10];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    fn get_used_gprs(&self) -> Vec<Self::GPR> {
+        GPR::iterator()
+            .filter(|x| self.used_gprs & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+    fn get_used_simd(&self) -> Vec<Self::SIMD> {
+        FPR::iterator()
+            .filter(|x| self.used_fprs & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+    fn acquire_temp_gpr(&mut self) -> Option<Self::GPR> {
+        let gpr = self.pick_temp_gpr();
+        if let Some(x) = gpr {
+            self.used_gprs_insert(x);
+        }
+        gpr
+    }
+    fn release_gpr(&mut self, gpr: Self::GPR) {
+        assert!(self.used_gprs_remove(&gpr));
+    }
+    fn reserve_unused_temp_gpr(&mut self, gpr: Self::GPR) -> Self::GPR {
+        assert!(!self.used_gprs_contains(&gpr));
+        self.used_gprs_insert(gpr);
+        gpr
+    }
+    fn reserve_gpr(&mut self, gpr: Self::GPR) {
+        self.used_gprs_insert(gpr);
+    }
+    fn push_used_gpr(&mut self, used_gprs: &[Self::GPR]) -> Result<usize, CompileError> {
+        for r in used_gprs.iter() {
+            self.assembler.emit_push(Size::S64, Location::GPR(*r))?;
+        }
+        Ok(used_gprs.len() * 16)
+    }
+    fn pop_used_gpr(&mut self, used_gprs: &[Self::GPR]) -> Result<(), CompileError> {
+        for r in used_gprs.iter().rev() {
+            self.emit_pop(Size::S64, Location::GPR(*r))?;
+        }
+        Ok(())
+    }
+    fn pick_simd(&self) -> Option<Self::SIMD> {
+        use FPR::*;
+        static REGS: &[FPR] = &[F0, F1, F2, F3, F4, F5, F6, F7];
+        for r in REGS {
+            if !self.used_fp_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused FP register for internal temporary use.
+    fn pick_temp_simd(&self) -> Option<FPR> {
+        use FPR::*;
+        static REGS: &[FPR] = &[F28, F29, F31];
+        for r in REGS {
+            if !self.used_fp_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    fn acquire_temp_simd(&mut self) -> Option<Self::SIMD> {
+        let fpr = self.pick_temp_simd();
+        if let Some(x) = fpr {
+            self.used_fprs_insert(x);
+        }
+        fpr
+    }
+    fn reserve_simd(&mut self, fpr: Self::SIMD) {
+        self.used_fprs_insert(fpr);
+    }
+    fn release_simd(&mut self, fpr: Self::SIMD) {
+        assert!(self.used_fprs_remove(&fpr));
+    }
+
+    fn push_used_simd(&mut self, used_neons: &[Self::SIMD]) -> Result<usize, CompileError> {
+        let stack_adjust = (used_neons.len() * 8) as u32;
+        self.extend_stack(stack_adjust)?;
+
+        for (i, r) in used_neons.iter().enumerate() {
+            self.assembler.emit_sd(
+                Size::S64,
+                Location::SIMD(*r),
+                Location::Memory(GPR::Sp, (i * 8) as i32),
+            )?;
+        }
+        Ok(stack_adjust as usize)
+    }
+    fn pop_used_simd(&mut self, used_neons: &[Self::SIMD]) -> Result<(), CompileError> {
+        for (i, r) in used_neons.iter().enumerate() {
+            self.assembler.emit_ld(
+                Size::S64,
+                false,
+                Location::SIMD(*r),
+                Location::Memory(GPR::Sp, (i * 8) as i32),
+            )?;
+        }
+        let stack_adjust = (used_neons.len() * 8) as u32;
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::Sp),
+            Location::Imm64(stack_adjust as _),
+            Location::GPR(GPR::Sp),
+        )
+    }
+
+    // Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)
+    fn round_stack_adjust(&self, value: usize) -> usize {
+        if value & 0xf != 0 {
+            ((value >> 4) + 1) << 4
+        } else {
+            value
+        }
+    }
+
+    /// Set the source location of the Wasm to the given offset.
+    fn set_srcloc(&mut self, offset: u32) {
+        self.src_loc = offset;
+    }
+
+    fn mark_address_range_with_trap_code(&mut self, code: TrapCode, begin: usize, end: usize) {
+        for i in begin..end {
+            self.trap_table.offset_to_code.insert(i, code);
+        }
+        self.mark_instruction_address_end(begin);
+    }
+    fn mark_address_with_trap_code(&mut self, code: TrapCode) {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        self.mark_instruction_address_end(offset);
+    }
+    /// Marks the instruction as trappable with trap code `code`. return "begin" offset
+    fn mark_instruction_with_trap_code(&mut self, code: TrapCode) -> usize {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        offset
+    }
+    fn mark_instruction_address_end(&mut self, begin: usize) {
+        self.instructions_address_map.push(InstructionAddressMap {
+            srcloc: SourceLoc::new(self.src_loc),
+            code_offset: begin,
+            code_len: self.assembler.get_offset().0 - begin,
+        });
+    }
+    /// Insert a StackOverflow (at offset 0)
+    fn insert_stackoverflow(&mut self) {
+        let offset = 0;
+        self.trap_table
+            .offset_to_code
+            .insert(offset, TrapCode::StackOverflow);
+        self.mark_instruction_address_end(offset);
+    }
+
+    /// Get all current TrapInformation
+    fn collect_trap_information(&self) -> Vec<TrapInformation> {
+        self.trap_table
+            .offset_to_code
+            .clone()
+            .into_iter()
+            .map(|(offset, code)| TrapInformation {
+                code_offset: offset as u32,
+                trap_code: code,
+            })
+            .collect()
+    }
+
+    fn instructions_address_map(&self) -> Vec<InstructionAddressMap> {
+        self.instructions_address_map.clone()
+    }
+    fn local_on_stack(&mut self, stack_offset: i32) -> Location {
+        Location::Memory(GPR::Fp, -stack_offset)
+    }
+    fn extend_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        let delta = if ImmType::Bits12Subtraction.compatible_imm(delta_stack_offset as _) {
+            Location::Imm64(delta_stack_offset as _)
+        } else {
+            self.assembler
+                .emit_mov_imm(Location::GPR(SCRATCH_REG), delta_stack_offset as _)?;
+            Location::GPR(SCRATCH_REG)
+        };
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::GPR(GPR::Sp),
+            delta,
+            Location::GPR(GPR::Sp),
+        )
+    }
+    fn truncate_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        let delta = if ImmType::Bits12.compatible_imm(delta_stack_offset as _) {
+            Location::Imm64(delta_stack_offset as _)
+        } else {
+            self.assembler
+                .emit_mov_imm(Location::GPR(SCRATCH_REG), delta_stack_offset as _)?;
+            Location::GPR(SCRATCH_REG)
+        };
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::Sp),
+            delta,
+            Location::GPR(GPR::Sp),
+        )
+    }
+    fn zero_location(&mut self, size: Size, location: Location) -> Result<(), CompileError> {
+        self.move_location(size, Location::GPR(GPR::XZero), location)
+    }
+    fn local_pointer(&self) -> Self::GPR {
+        GPR::Fp
+    }
+    // push a value on the stack for a native call
+    fn move_location_for_native(
+        &mut self,
+        _size: Size,
+        loc: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match loc {
+            Location::Imm64(_)
+            | Location::Imm32(_)
+            | Location::Imm8(_)
+            | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc, Location::GPR(SCRATCH_REG))?;
+                self.move_location(Size::S64, Location::GPR(SCRATCH_REG), dest)
+            }
+            _ => self.move_location(Size::S64, loc, dest),
+        }
+    }
+
+    fn is_local_on_stack(&self, idx: usize) -> bool {
+        idx > 9
+    }
+
+    // Determine a local's location.
+    fn get_local_location(&self, idx: usize, callee_saved_regs_size: usize) -> Location {
+        // Use callee-saved registers for the first locals.
+        match idx {
+            0 => Location::GPR(GPR::X9),
+            1 => Location::GPR(GPR::X18),
+            2 => Location::GPR(GPR::X19),
+            3 => Location::GPR(GPR::X20),
+            4 => Location::GPR(GPR::X21),
+            5 => Location::GPR(GPR::X22),
+            6 => Location::GPR(GPR::X23),
+            7 => Location::GPR(GPR::X24),
+            8 => Location::GPR(GPR::X25),
+            9 => Location::GPR(GPR::X26),
+            _ => Location::Memory(GPR::Fp, -(((idx - 9) * 8 + callee_saved_regs_size) as i32)),
+        }
+    }
+
+    // Move a local to the stack
+    fn move_local(&mut self, stack_offset: i32, location: Location) -> Result<(), CompileError> {
+        self.move_location(
+            Size::S64,
+            location,
+            Location::Memory(GPR::Fp, -stack_offset),
+        )?;
+
+        match location {
+            Location::GPR(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: UnwindRegister::GPR(x),
+                bp_neg_offset: stack_offset,
+            }),
+            Location::SIMD(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: UnwindRegister::FPR(x),
+                bp_neg_offset: stack_offset,
+            }),
+            _ => (),
+        }
+        Ok(())
+    }
+    fn list_to_save(&self, _calling_convention: CallingConvention) -> Vec<Location> {
+        vec![]
+    }
+
+    /// Get registers for first N function call parameters.
+    fn get_param_registers(&self, _calling_convention: CallingConvention) -> &'static [Self::GPR] {
+        &[
+            GPR::X10,
+            GPR::X11,
+            GPR::X12,
+            GPR::X13,
+            GPR::X14,
+            GPR::X15,
+            GPR::X16,
+            GPR::X17,
+        ]
+    }
+
+    fn get_param_location(
+        &self,
+        idx: usize,
+        _sz: Size,
+        stack_args: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        let register_params: &[GPR] = self.get_param_registers(calling_convention);
+        if let Some(reg) = register_params.get(idx) {
+            Location::GPR(*reg)
+        } else {
+            let loc = Location::Memory(GPR::Sp, *stack_args as i32);
+            *stack_args += 8;
+            loc
+        }
+    }
+    // Get call param location, MUST be called in order!
+    fn get_call_param_location(
+        &self,
+        return_slots: usize,
+        idx: usize,
+        _sz: Size,
+        stack_args: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        let return_values_memory_size =
+            8 * return_slots.saturating_sub(RISCV_RETURN_VALUE_REGISTERS.len()) as i32;
+        self.get_param_registers(calling_convention)
+            .get(idx)
+            .map_or_else(
+                || {
+                    let loc = Location::Memory(
+                        GPR::Fp,
+                        16 + return_values_memory_size + *stack_args as i32,
+                    );
+                    *stack_args += 8;
+                    loc
+                },
+                |reg| Location::GPR(*reg),
+            )
+    }
+    fn get_simple_param_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
+    ) -> Self::GPR {
+        self.get_param_registers(calling_convention)[idx]
+    }
+
+    fn get_return_value_location(
+        &self,
+        idx: usize,
+        stack_location: &mut usize,
+        _calling_convention: CallingConvention,
+    ) -> AbstractLocation<Self::GPR, Self::SIMD> {
+        RISCV_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                let loc = Location::Memory(GPR::Sp, *stack_location as i32);
+                *stack_location += 8;
+                loc
+            },
+            |reg| Location::GPR(*reg),
+        )
+    }
+
+    fn get_call_return_value_location(
+        &self,
+        idx: usize,
+        _calling_convention: CallingConvention,
+    ) -> AbstractLocation<Self::GPR, Self::SIMD> {
+        RISCV_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                Location::Memory(
+                    GPR::Fp,
+                    (16 + (idx - RISCV_RETURN_VALUE_REGISTERS.len()) * 8) as i32,
+                )
+            },
+            |reg| Location::GPR(*reg),
+        )
+    }
+
+    // move a location to another
+    fn move_location(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match (source, dest) {
+            (Location::GPR(_), Location::GPR(_)) => self.assembler.emit_mov(size, source, dest),
+            (Location::Imm32(_) | Location::Imm64(_), Location::GPR(_)) => self
+                .assembler
+                .emit_mov_imm(dest, source.imm_value_scalar().unwrap()),
+            (Location::GPR(_), Location::Memory(addr, offset)) => {
+                let addr = if ImmType::Bits12.compatible_imm(offset as _) {
+                    dest
+                } else {
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(SCRATCH_REG), offset as _)?;
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(addr),
+                        Location::GPR(SCRATCH_REG),
+                        Location::GPR(SCRATCH_REG),
+                    )?;
+                    Location::Memory(SCRATCH_REG, 0)
+                };
+                self.assembler.emit_sd(size, source, addr)
+            }
+            (Location::SIMD(_), Location::Memory(..)) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(size, source, Location::GPR(tmp))?;
+                self.move_location(size, Location::GPR(tmp), dest)?;
+                self.release_gpr(tmp);
+                Ok(())
+            }
+            (Location::Memory(addr, offset), Location::GPR(_)) => {
+                let addr = if ImmType::Bits12.compatible_imm(offset as _) {
+                    source
+                } else {
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(SCRATCH_REG), offset as _)?;
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(addr),
+                        Location::GPR(SCRATCH_REG),
+                        Location::GPR(SCRATCH_REG),
+                    )?;
+                    Location::Memory(SCRATCH_REG, 0)
+                };
+                self.assembler.emit_ld(size, false, dest, addr)
+            }
+            (Location::GPR(_), Location::SIMD(_)) => self.assembler.emit_mov(size, source, dest),
+            (Location::SIMD(_), Location::GPR(_)) => self.assembler.emit_mov(size, source, dest),
+            (Location::SIMD(_), Location::SIMD(_)) => self.assembler.emit_mov(size, source, dest),
+            _ => todo!("unsupported move: {size:?} {source:?} {dest:?}"),
+        }
+    }
+
+    // move a location to another
+    fn move_location_extend(
+        &mut self,
+        size_val: Size,
+        signed: bool,
+        source: Location,
+        size_op: Size,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        if size_op != Size::S64 {
+            codegen_error!("singlepass move_location_extend unreachable");
+        }
+        let mut temps = vec![];
+        let dst = self.location_to_reg(size_op, dest, &mut temps, ImmType::None, false, None)?;
+        let src = match (size_val, signed, source) {
+            (Size::S64, _, _) => source,
+            (_, _, Location::GPR(_)) => {
+                self.assembler.emit_extend(size_val, signed, source, dst)?;
+                dst
+            }
+            (_, _, Location::Memory(_, _)) => {
+                self.assembler.emit_ld(size_val, signed, dst, source)?;
+                dst
+            }
+            _ => codegen_error!(
+                "singlepass can't emit move_location_extend {:?} {:?} {:?} => {:?} {:?}",
+                size_val,
+                signed,
+                source,
+                size_op,
+                dest
+            ),
+        };
+        if src != dst {
+            self.move_location(size_op, src, dst)?;
+        }
+        if dst != dest {
+            self.move_location(size_op, dst, dest)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    // Init the stack loc counter
+    fn init_stack_loc(
+        &mut self,
+        init_stack_loc_cnt: u64,
+        last_stack_loc: Location,
+    ) -> Result<(), CompileError> {
+        let label = self.assembler.get_label();
+        let mut temps = vec![];
+        let dest = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(dest);
+        let cnt = self.location_to_reg(
+            Size::S64,
+            Location::Imm64(init_stack_loc_cnt),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+        match last_stack_loc {
+            Location::GPR(_) => codegen_error!("singlepass init_stack_loc unreachable"),
+            Location::SIMD(_) => codegen_error!("singlepass init_stack_loc unreachable"),
+            Location::Memory(reg, offset) => {
+                if ImmType::Bits12.compatible_imm(offset as _) {
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(reg),
+                        Location::Imm64(offset as _),
+                        Location::GPR(dest),
+                    )?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), offset as _)?;
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(reg),
+                        Location::GPR(tmp),
+                        Location::GPR(dest),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit init_stack_loc {:?}", last_stack_loc),
+        };
+        self.assembler.emit_label(label)?;
+        self.assembler.emit_sd(
+            Size::S64,
+            Location::GPR(GPR::XZero),
+            Location::Memory(dest, 0),
+        )?;
+        self.assembler
+            .emit_sub(Size::S64, cnt, Location::Imm64(1), cnt)?;
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(dest),
+            Location::Imm64(8),
+            Location::GPR(dest),
+        )?;
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+        self.assembler.emit_on_true_label(cnt, label, jmp_tmp)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    // Restore save_area
+    fn restore_saved_area(&mut self, saved_area_offset: i32) -> Result<(), CompileError> {
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::GPR(GPR::Fp),
+            Location::Imm64(saved_area_offset as _),
+            Location::GPR(GPR::Sp),
+        )
+    }
+
+    // Pop a location
+    fn pop_location(&mut self, location: Location) -> Result<(), CompileError> {
+        self.emit_pop(Size::S64, location)
+    }
+    fn assembler_finalize(
+        self,
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<FinalizedAssembly, CompileError> {
+        Ok(FinalizedAssembly {
+            body: self.assembler.finalize().map_err(|e| {
+                CompileError::Codegen(format!("Assembler failed finalization with: {e:?}"))
+            })?,
+            assembly_comments,
+        })
+    }
+    fn get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        self.assembler.finalize_function()?;
+        Ok(())
+    }
+
+    fn emit_function_prolog(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::GPR(GPR::Sp),
+            Location::Imm64(16),
+            Location::GPR(GPR::Sp),
+        )?;
+        self.emit_unwind_op(UnwindOps::SubtractFP { up_to_sp: 16 });
+
+        self.assembler.emit_sd(
+            Size::S64,
+            Location::GPR(GPR::X1), // return address register
+            Location::Memory(GPR::Sp, 8),
+        )?;
+        self.assembler.emit_sd(
+            Size::S64,
+            Location::GPR(GPR::Fp),
+            Location::Memory(GPR::Sp, 0),
+        )?;
+        self.emit_unwind_op(UnwindOps::SaveRegister {
+            reg: UnwindRegister::GPR(GPR::X1),
+            bp_neg_offset: 8,
+        });
+        self.emit_unwind_op(UnwindOps::SaveRegister {
+            reg: UnwindRegister::GPR(GPR::Fp),
+            bp_neg_offset: 16,
+        });
+
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::Sp), Location::GPR(GPR::Fp))?;
+        self.emit_unwind_op(UnwindOps::DefineNewFrame);
+        Ok(())
+    }
+
+    fn emit_function_epilog(&mut self) -> Result<(), CompileError> {
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::Fp), Location::GPR(GPR::Sp))?;
+        self.assembler.emit_ld(
+            Size::S64,
+            false,
+            Location::GPR(GPR::X1), // return address register
+            Location::Memory(GPR::Sp, 8),
+        )?;
+        self.assembler.emit_ld(
+            Size::S64,
+            false,
+            Location::GPR(GPR::Fp),
+            Location::Memory(GPR::Sp, 0),
+        )?;
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::Sp),
+            Location::Imm64(16),
+            Location::GPR(GPR::Sp),
+        )?;
+
+        Ok(())
+    }
+    fn emit_function_return_float(&mut self) -> Result<(), CompileError> {
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::X10), Location::SIMD(FPR::F10))
+    }
+    fn canonicalize_nan(
+        &mut self,
+        sz: Size,
+        input: Location,
+        output: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        // use FMAX (input, intput) => output to automaticaly normalize the NaN
+        match (sz, input, output) {
+            (Size::S32, Location::SIMD(_), Location::SIMD(_)) => {
+                self.assembler.emit_fmax(sz, input, input, output)?;
+            }
+            (Size::S64, Location::SIMD(_), Location::SIMD(_)) => {
+                self.assembler.emit_fmax(sz, input, input, output)?;
+            }
+            (Size::S32, Location::SIMD(_), _) | (Size::S64, Location::SIMD(_), _) => {
+                let tmp = self.location_to_fpr(sz, output, &mut temps, ImmType::None, false)?;
+                self.assembler.emit_fmax(sz, input, input, tmp)?;
+                self.move_location(sz, tmp, output)?;
+            }
+            (Size::S32, Location::Memory(_, _), _) | (Size::S64, Location::Memory(_, _), _) => {
+                let src = self.location_to_fpr(sz, input, &mut temps, ImmType::None, true)?;
+                let tmp = self.location_to_fpr(sz, output, &mut temps, ImmType::None, false)?;
+                self.assembler.emit_fmax(sz, src, src, tmp)?;
+                if tmp != output {
+                    self.move_location(sz, tmp, output)?;
+                }
+            }
+            _ => codegen_error!(
+                "singlepass can't emit canonicalize_nan {:?} {:?} {:?}",
+                sz,
+                input,
+                output
+            ),
+        }
+
+        for r in temps {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn emit_illegal_op(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        let offset = self.assembler.get_offset().0;
+        self.assembler.emit_udf(trap as u8)?;
+        self.mark_instruction_address_end(offset);
+        Ok(())
+    }
+    fn get_label(&mut self) -> Label {
+        self.assembler.new_dynamic_label()
+    }
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_label(label)
+    }
+    fn get_gpr_for_call(&self) -> Self::GPR {
+        GPR::X1
+    }
+    fn emit_call_register(&mut self, register: Self::GPR) -> Result<(), CompileError> {
+        self.assembler.emit_call_register(register)
+    }
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_call_label(label)
+    }
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        _location: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_indirect_call_with_trampoline unimplemented")
+    }
+    fn emit_call_location(&mut self, location: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let loc = self.location_to_reg(
+            Size::S64,
+            location,
+            &mut temps,
+            ImmType::None,
+            true,
+            Some(self.get_gpr_for_call()),
+        )?;
+        match loc {
+            Location::GPR(reg) => self.assembler.emit_call_register(reg),
+            _ => codegen_error!("singlepass can't emit CALL Location"),
+        }?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_brk()
+    }
+    fn location_add(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(size, source, &mut temps, ImmType::Bits12, true, None)?;
+        let dst = self.location_to_reg(size, dest, &mut temps, ImmType::None, true, None)?;
+        self.assembler.emit_add(size, dst, src, dst)?;
+        if dst != dest {
+            self.move_location(size, dst, dest)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn location_cmp(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_cmp not implemented")
+    }
+    fn jmp_unconditional(&mut self, label: Label) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler.emit_j_label(label, Some(tmp))?;
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn jmp_on_condition(
+        &mut self,
+        cond: UnsignedCondition,
+        size: Size,
+        loc_a: AbstractLocation<Self::GPR, Self::SIMD>,
+        loc_b: AbstractLocation<Self::GPR, Self::SIMD>,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        let c = match cond {
+            UnsignedCondition::Equal => Condition::Eq,
+            UnsignedCondition::NotEqual => Condition::Ne,
+            UnsignedCondition::Above => Condition::Gtu,
+            UnsignedCondition::AboveEqual => Condition::Geu,
+            UnsignedCondition::Below => Condition::Ltu,
+            UnsignedCondition::BelowEqual => Condition::Leu,
+        };
+
+        let mut temps = vec![];
+        let loc_a = self.location_to_reg(size, loc_a, &mut temps, ImmType::None, true, None)?;
+        let loc_b = self.location_to_reg(size, loc_b, &mut temps, ImmType::None, true, None)?;
+
+        if size != Size::S64 {
+            self.assembler.emit_extend(size, false, loc_a, loc_a)?;
+            self.assembler.emit_extend(size, false, loc_b, loc_b)?;
+        }
+
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(tmp);
+        self.assembler
+            .emit_jmp_on_condition(c, loc_a, loc_b, label, tmp)?;
+
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    // jmp table
+    fn emit_jmp_to_jumptable(&mut self, label: Label, cond: Location) -> Result<(), CompileError> {
+        let tmp1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.assembler.emit_load_label(tmp1, label)?;
+        self.move_location(Size::S32, cond, Location::GPR(tmp2))?;
+
+        // Multiply by 8, for RISC-V, a jump is made via 2 instructions:
+        // auipc and j. This way we can navigate greater code regions.
+        self.assembler.emit_sll(
+            Size::S32,
+            Location::GPR(tmp2),
+            Location::Imm32(3),
+            Location::GPR(tmp2),
+        )?;
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp2),
+        )?;
+        self.assembler.emit_j_register(tmp2)?;
+        self.release_gpr(tmp2);
+        self.release_gpr(tmp1);
+        Ok(())
+    }
+
+    fn align_for_loop(&mut self) -> Result<(), CompileError> {
+        // nothing to do on RISC-V
+        Ok(())
+    }
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_ret()
+    }
+    fn emit_push(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.assembler.emit_push(size, loc)
+    }
+    fn emit_pop(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.assembler.emit_pop(size, loc)
+    }
+    // relaxed binop based...
+    fn emit_relaxed_mov(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_mov, sz, src, dst)
+    }
+    fn emit_relaxed_cmp(
+        &mut self,
+        _sz: Size,
+        _src: Location,
+        _dst: Location,
+    ) -> Result<(), CompileError> {
+        todo!();
+    }
+    fn emit_memory_fence(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_rwfence()
+    }
+    fn emit_relaxed_sign_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+
+        match (src, dst) {
+            (Location::Memory(reg, offset), Location::GPR(_)) => {
+                let src = if ImmType::Bits12.compatible_imm(offset as _) {
+                    src
+                } else {
+                    let tmp =
+                        self.location_to_reg(sz_src, src, &mut temps, ImmType::None, true, None)?;
+                    self.assembler.emit_mov_imm(tmp, offset as _)?;
+                    self.assembler
+                        .emit_add(Size::S64, Location::GPR(reg), tmp, tmp)?;
+                    let Location::GPR(tmp) = tmp else {
+                        unreachable!()
+                    };
+                    Location::Memory(tmp, 0)
+                };
+                self.assembler.emit_ld(sz_src, true, dst, src)?;
+            }
+            _ => {
+                let src =
+                    self.location_to_reg(sz_src, src, &mut temps, ImmType::None, true, None)?;
+                let dest =
+                    self.location_to_reg(sz_dst, dst, &mut temps, ImmType::None, false, None)?;
+                self.assembler.emit_extend(sz_src, true, src, dest)?;
+                if dst != dest {
+                    self.move_location(sz_dst, dest, dst)?;
+                }
+            }
+        }
+
+        for r in temps {
+            self.release_gpr(r);
+        }
+
+        Ok(())
+    }
+    fn emit_imul_imm32(
+        &mut self,
+        size: Size,
+        imm32: u32,
+        gpr: Self::GPR,
+    ) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_mov_imm(Location::GPR(tmp), imm32 as _)?;
+        self.assembler.emit_mul(
+            size,
+            Location::GPR(gpr),
+            Location::GPR(tmp),
+            Location::GPR(gpr),
+        )?;
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn emit_binop_add32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_add,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_sub32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sub,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12Subtraction,
+        )
+    }
+    fn emit_binop_mul32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_mul,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn emit_binop_udiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_sdiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let label_nooverflow = self.assembler.get_label();
+        let tmp = self.location_to_reg(
+            Size::S32,
+            Location::Imm32(i32::MIN as u32),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+        self.assembler.emit_cmp(Condition::Ne, tmp, src1, tmp)?;
+        self.assembler
+            .emit_on_true_label(tmp, label_nooverflow, jmp_tmp)?;
+        self.move_location(Size::S32, Location::Imm32(-1i32 as _), tmp)?;
+        self.assembler.emit_cmp(Condition::Eq, tmp, src2, tmp)?;
+        self.assembler
+            .emit_on_true_label_far(tmp, integer_overflow, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_label(label_nooverflow)?;
+        self.assembler.emit_sdiv(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_urem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_urem(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_srem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_srem(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_and32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_and,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_or32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_or,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_xor32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_xor,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn i32_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ge, loc_a, loc_b, ret, true)
+    }
+    fn i32_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Gt, loc_a, loc_b, ret, true)
+    }
+    fn i32_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Le, loc_a, loc_b, ret, true)
+    }
+    fn i32_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Lt, loc_a, loc_b, ret, true)
+    }
+    fn i32_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Geu, loc_a, loc_b, ret, false)
+    }
+    fn i32_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Gtu, loc_a, loc_b, ret, false)
+    }
+    fn i32_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Leu, loc_a, loc_b, ret, false)
+    }
+    fn i32_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ltu, loc_a, loc_b, ret, false)
+    }
+    fn i32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ne, loc_a, loc_b, ret, true)
+    }
+    fn i32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Eq, loc_a, loc_b, ret, true)
+    }
+    fn i32_clz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_clz(Size::S32, loc, ret)
+    }
+    fn i32_ctz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_ctz(Size::S32, loc, ret)
+    }
+    fn i32_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_popcnt(Size::S32, loc, ret)
+    }
+    fn i32_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sll,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32,
+        )
+    }
+    fn i32_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_srl,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32,
+        )
+    }
+    fn i32_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sra,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32,
+        )
+    }
+    fn i32_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_rol(Size::S32, loc_a, loc_b, ret, ImmType::Shift32)
+    }
+    fn i32_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_ror(Size::S32, loc_a, loc_b, ret, ImmType::Shift32)
+    }
+    fn i32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S32, true, ret, addr),
+        )
+    }
+    fn i32_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S8, false, ret, addr),
+        )
+    }
+    fn i32_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S8, true, ret, addr),
+        )
+    }
+    fn i32_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S16, false, ret, addr),
+        )
+    }
+    fn i32_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S16, true, ret, addr),
+        )
+    }
+    fn i32_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S32, true, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S8, true, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S16, true, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S32, value, addr),
+        )
+    }
+    fn i32_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S8, value, addr),
+        )
+    }
+    fn i32_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S16, value, addr),
+        )
+    }
+    fn i32_atomic_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S32, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i32_atomic_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S8, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i32_atomic_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S16, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i32_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i32_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S32, ret, addr, new, cmp),
+        )
+    }
+    fn i32_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S8, ret, addr, new, cmp),
+        )
+    }
+    fn i32_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S16, ret, addr, new, cmp),
+        )
+    }
+    fn emit_call_with_reloc(
+        &mut self,
+        _calling_convention: CallingConvention,
+        reloc_target: RelocationTarget,
+    ) -> Result<Vec<Relocation>, CompileError> {
+        let mut relocations = vec![];
+        let next = self.get_label();
+        let reloc_at = self.assembler.get_offset().0;
+        self.emit_label(next)?; // this is to be sure the current imm26 value is 0
+        self.assembler.emit_call_label(next)?;
+        relocations.push(Relocation {
+            kind: RelocationKind::RiscvCall,
+            reloc_target,
+            offset: reloc_at as u32,
+            addend: 0,
+        });
+        Ok(relocations)
+    }
+    fn emit_binop_add64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_add,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_sub64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sub,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12Subtraction,
+        )
+    }
+    fn emit_binop_mul64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_mul,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn emit_binop_udiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_sdiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let label_nooverflow = self.assembler.get_label();
+        let tmp = self.location_to_reg(
+            Size::S64,
+            Location::Imm64(i64::MIN as u64),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+
+        self.assembler.emit_cmp(Condition::Ne, tmp, src1, tmp)?;
+        self.assembler
+            .emit_on_true_label(tmp, label_nooverflow, jmp_tmp)?;
+        self.move_location(Size::S64, Location::Imm64(-1i64 as _), tmp)?;
+        self.assembler.emit_cmp(Condition::Eq, tmp, src2, tmp)?;
+        self.assembler
+            .emit_on_true_label_far(tmp, integer_overflow, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_label(label_nooverflow)?;
+        self.assembler.emit_sdiv(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_urem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_urem(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_srem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        let jmp_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(jmp_tmp);
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero, jmp_tmp)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_srem(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_and64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_and,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_or64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_or,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_xor64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_xor,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn i64_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ge, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Gt, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Le, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Lt, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Geu, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Gtu, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Leu, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ltu, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ne, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Eq, loc_a, loc_b, ret)
+    }
+    fn i64_clz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_clz(Size::S64, loc, ret)
+    }
+    fn i64_ctz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_ctz(Size::S64, loc, ret)
+    }
+    fn i64_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_popcnt(Size::S64, loc, ret)
+    }
+    fn i64_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sll,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64,
+        )
+    }
+    fn i64_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_srl,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64,
+        )
+    }
+    fn i64_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sra,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64,
+        )
+    }
+    fn i64_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_rol(Size::S64, loc_a, loc_b, ret, ImmType::Shift64)
+    }
+    fn i64_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_ror(Size::S64, loc_a, loc_b, ret, ImmType::Shift64)
+    }
+    fn i64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S64, true, ret, addr),
+        )
+    }
+    fn i64_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S8, false, ret, addr),
+        )
+    }
+    fn i64_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S8, true, ret, addr),
+        )
+    }
+    fn i64_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S32, false, ret, addr),
+        )
+    }
+    fn i64_load_32s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S32, true, ret, addr),
+        )
+    }
+    fn i64_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S16, false, ret, addr),
+        )
+    }
+    fn i64_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_load(Size::S16, true, ret, addr),
+        )
+    }
+    fn i64_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S64, true, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S8, false, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S16, false, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S32, false, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S64, value, addr),
+        )
+    }
+    fn i64_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S8, value, addr),
+        )
+    }
+    fn i64_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S16, value, addr),
+        )
+    }
+    fn i64_save_32(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_maybe_unaligned_store(Size::S32, value, addr),
+        )
+    }
+    fn i64_atomic_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S64, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i64_atomic_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S8, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i64_atomic_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S16, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i64_atomic_save_32(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_store(Size::S32, value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_rwfence()
+    }
+    fn i64_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_add_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Add, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_sub_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Sub, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_and_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::And, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_or_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Or, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xor_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Xor, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S64, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S8, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S16, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_xchg_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_atomic_binop3(AtomicBinaryOp::Exchange, Size::S32, ret, addr, loc)
+            },
+        )
+    }
+    fn i64_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S64, ret, addr, new, cmp),
+        )
+    }
+    fn i64_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S8, ret, addr, new, cmp),
+        )
+    }
+    fn i64_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S16, ret, addr, new, cmp),
+        )
+    }
+    fn i64_atomic_cmpxchg_32u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_cmpxchg(Size::S32, ret, addr, new, cmp),
+        )
+    }
+    fn f32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S32, false, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn f32_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        canonicalize: bool,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_store(Size::S32, value, Location::Memory(addr, 0))
+                } else {
+                    this.canonicalize_nan(Size::S32, value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+    fn f64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_load(Size::S64, false, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn f64_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        addr: Location,
+        canonicalize: bool,
+        _need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_store(Size::S64, value, Location::Memory(addr, 0))
+                } else {
+                    this.canonicalize_nan(Size::S64, value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+    fn convert_f64_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.convert_int_to_float(loc, Size::S64, ret, Size::S64, signed)
+    }
+    fn convert_f64_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.convert_int_to_float(loc, Size::S32, ret, Size::S64, signed)
+    }
+    fn convert_f32_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.convert_int_to_float(loc, Size::S64, ret, Size::S32, signed)
+    }
+    fn convert_f32_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.convert_int_to_float(loc, Size::S32, ret, Size::S32, signed)
+    }
+    fn convert_i64_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        self.convert_float_to_int(loc, Size::S64, ret, Size::S64, signed, sat)
+    }
+    fn convert_i32_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        self.convert_float_to_int(loc, Size::S64, ret, Size::S32, signed, sat)
+    }
+    fn convert_i64_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        self.convert_float_to_int(loc, Size::S32, ret, Size::S64, signed, sat)
+    }
+    fn convert_i32_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        self.convert_float_to_int(loc, Size::S32, ret, Size::S32, signed, sat)
+    }
+    fn convert_f64_f32(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.convert_float_to_float(loc, Size::S32, ret, Size::S64)
+    }
+    fn convert_f32_f64(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.convert_float_to_float(loc, Size::S64, ret, Size::S32)
+    }
+    fn f64_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_fp(Assembler::emit_fneg, Size::S64, loc, ret, true)
+    }
+    fn f64_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let mask = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x7fffffffffffffffi64)?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp),
+            Location::GPR(mask),
+            Location::GPR(tmp),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmp), ret)?;
+
+        self.release_gpr(tmp);
+        self.release_gpr(mask);
+        Ok(())
+    }
+    fn emit_i64_copysign(&mut self, tmp1: Self::GPR, tmp2: Self::GPR) -> Result<(), CompileError> {
+        let mask = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x7fffffffffffffffu64 as _)?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::GPR(mask),
+            Location::GPR(tmp1),
+        )?;
+
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x8000000000000000u64 as _)?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp2),
+            Location::GPR(mask),
+            Location::GPR(tmp2),
+        )?;
+
+        self.release_gpr(mask);
+        self.assembler.emit_or(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp1),
+        )
+    }
+    fn f64_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_fp(Assembler::emit_fsqrt, Size::S64, loc, ret, true)
+    }
+    fn f64_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rtz, Size::S64, loc, ret)
+    }
+    fn f64_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rup, Size::S64, loc, ret)
+    }
+    fn f64_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rdn, Size::S64, loc, ret)
+    }
+    fn f64_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rne, Size::S64, loc, ret)
+    }
+    fn f64_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Ge, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Gt, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Le, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Lt, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Ne, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Eq, Size::S64, loc_a, loc_b, ret)
+    }
+    fn f64_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fmin,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            true,
+        )
+    }
+    fn f64_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fmax,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            true,
+        )
+    }
+    fn f64_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_add,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f64_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_sub,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f64_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_mul,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f64_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fdiv,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f32_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_fp(Assembler::emit_fneg, Size::S32, loc, ret, true)
+    }
+    fn f32_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let mask = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x7fffffffi64)?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp),
+            Location::GPR(mask),
+            Location::GPR(tmp),
+        )?;
+        self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+
+        self.release_gpr(tmp);
+        self.release_gpr(mask);
+        Ok(())
+    }
+    fn emit_i32_copysign(&mut self, tmp1: Self::GPR, tmp2: Self::GPR) -> Result<(), CompileError> {
+        let mask = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x7fffffffu32 as _)?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp1),
+            Location::GPR(mask),
+            Location::GPR(tmp1),
+        )?;
+
+        self.assembler
+            .emit_mov_imm(Location::GPR(mask), 0x80000000u32 as _)?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp2),
+            Location::GPR(mask),
+            Location::GPR(tmp2),
+        )?;
+
+        self.release_gpr(mask);
+        self.assembler.emit_or(
+            Size::S32,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp1),
+        )
+    }
+    fn f32_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_fp(Assembler::emit_fsqrt, Size::S32, loc, ret, true)
+    }
+    fn f32_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rtz, Size::S32, loc, ret)
+    }
+    fn f32_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rup, Size::S32, loc, ret)
+    }
+    fn f32_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rdn, Size::S32, loc, ret)
+    }
+    fn f32_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_fcvt_with_rounding(RoundingMode::Rne, Size::S32, loc, ret)
+    }
+    fn f32_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Ge, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Gt, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Le, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Lt, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Ne, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_fcmp(Condition::Eq, Size::S32, loc_a, loc_b, ret)
+    }
+    fn f32_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fmin,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            true,
+        )
+    }
+    fn f32_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fmax,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            true,
+        )
+    }
+    fn f32_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_add,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f32_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_sub,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f32_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_mul,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn f32_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_fp(
+            Assembler::emit_fdiv,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+            false,
+        )
+    }
+    fn gen_std_trampoline(
+        &self,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        gen_std_trampoline_riscv(sig, calling_convention)
+    }
+    fn gen_std_dynamic_import_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        sig: &FunctionType,
+        _calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        gen_std_dynamic_import_trampoline_riscv(vmoffsets, sig)
+    }
+    // Singlepass calls import functions through a trampoline.
+    fn gen_import_call_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        index: FunctionIndex,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<CustomSection, CompileError> {
+        gen_import_call_trampoline_riscv(vmoffsets, index, sig, calling_convention)
+    }
+    #[cfg(feature = "unwind")]
+    fn gen_dwarf_unwind_info(&mut self, code_len: usize) -> Option<UnwindInstructions> {
+        let mut instructions = vec![];
+        for &(instruction_offset, ref inst) in &self.unwind_ops {
+            let instruction_offset = instruction_offset as u32;
+            match *inst {
+                UnwindOps::PushFP { up_to_sp } => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaOffset(up_to_sp as i32),
+                    ));
+                    instructions.push((
+                        instruction_offset,
+                        // TODO: use RiscV::FP: https://github.com/gimli-rs/gimli/pull/802
+                        CallFrameInstruction::Offset(RiscV::X8, -(up_to_sp as i32)),
+                    ));
+                }
+                UnwindOps::DefineNewFrame => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaRegister(RiscV::X8),
+                    ));
+                }
+                UnwindOps::SaveRegister { reg, bp_neg_offset } => instructions.push((
+                    instruction_offset,
+                    CallFrameInstruction::Offset(reg.dwarf_index(), -bp_neg_offset),
+                )),
+                UnwindOps::SubtractFP { up_to_sp } => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaOffset(up_to_sp as i32),
+                    ));
+                }
+                UnwindOps::Push2Regs { .. } => unimplemented!(),
+            }
+        }
+        Some(UnwindInstructions {
+            instructions,
+            len: code_len as u32,
+        })
+    }
+    #[cfg(not(feature = "unwind"))]
+    fn gen_dwarf_unwind_info(&mut self, _code_len: usize) -> Option<UnwindInstructions> {
+        None
+    }
+    fn gen_windows_unwind_info(&mut self, _code_len: usize) -> Option<Vec<u8>> {
+        None
+    }
+}
diff --git a/lib/compiler-singlepass/src/machine_x64.rs b/lib/compiler-singlepass/src/machine_x64.rs
index 5bb3655d37..eaabce6079 100644
--- a/lib/compiler-singlepass/src/machine_x64.rs
+++ b/lib/compiler-singlepass/src/machine_x64.rs
@@ -1,25 +1,35 @@
-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 dynasmrt::{x64::X64Relocation, DynasmError, VecAssembler};
+use crate::{
+    codegen_error,
+    common_decl::*,
+    emitter_x64::*,
+    location::{Location as AbstractLocation, Reg},
+    machine::*,
+    unwind::{UnwindInstructions, UnwindOps, UnwindRegister},
+    x64_decl::{ArgumentRegisterAllocator, GPR, X64Register, XMM},
+};
+use dynasmrt::{DynasmError, VecAssembler, x64::X64Relocation};
 #[cfg(feature = "unwind")]
-use gimli::{write::CallFrameInstruction, X86_64};
-use std::ops::{Deref, DerefMut};
-use wasmer_compiler::wasmparser::ValType as WpType;
+use gimli::{X86_64, write::CallFrameInstruction};
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+};
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationKind, RelocationTarget},
+        section::{CustomSection, CustomSectionProtection, SectionBody},
+    },
+    wasmparser::MemArg,
+};
 use wasmer_types::{
-    CallingConvention, CompileError, CpuFeature, CustomSection, CustomSectionProtection,
-    Relocation, RelocationKind, RelocationTarget, SectionBody, Target,
+    CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, Type,
+    VMOffsets,
+    target::{CallingConvention, CpuFeature, Target},
 };
-use wasmer_types::{FunctionBody, InstructionAddressMap, SourceLoc, TrapInformation};
-use wasmer_types::{FunctionIndex, FunctionType, TrapCode, Type, VMOffsets};
 
 type Assembler = VecAssembler<X64Relocation>;
 
@@ -28,27 +38,27 @@ pub struct AssemblerX64 {
     pub inner: Assembler,
     /// the simd instructions set on the target.
     /// Currently only supports SSE 4.2 and AVX
-    pub simd_arch: Option<CpuFeature>,
+    pub simd_arch: CpuFeature,
     /// Full Target cpu
     pub target: Option<Target>,
 }
 
 impl AssemblerX64 {
     fn new(baseaddr: usize, target: Option<Target>) -> Result<Self, CompileError> {
-        let simd_arch = if target.is_none() {
-            Some(CpuFeature::SSE42)
-        } else {
-            let target = target.as_ref().unwrap();
-            if target.cpu_features().contains(CpuFeature::AVX) {
-                Some(CpuFeature::AVX)
-            } else if target.cpu_features().contains(CpuFeature::SSE42) {
-                Some(CpuFeature::SSE42)
-            } else {
-                return Err(CompileError::UnsupportedTarget(
-                    "x86_64 without AVX or SSE 4.2, use -m avx to enable".to_string(),
-                ));
-            }
-        };
+        let simd_arch = target.as_ref().map_or_else(
+            || Ok(CpuFeature::SSE42),
+            |target| {
+                if target.cpu_features().contains(CpuFeature::AVX) {
+                    Ok(CpuFeature::AVX)
+                } else if target.cpu_features().contains(CpuFeature::SSE42) {
+                    Ok(CpuFeature::SSE42)
+                } else {
+                    Err(CompileError::UnsupportedTarget(
+                        "x86_64 without AVX or SSE 4.2, use -m avx to enable".to_string(),
+                    ))
+                }
+            },
+        )?;
 
         Ok(Self {
             inner: Assembler::new(baseaddr),
@@ -78,51 +88,6 @@ impl DerefMut for AssemblerX64 {
 
 type Location = AbstractLocation<GPR, XMM>;
 
-#[cfg(feature = "unwind")]
-fn dwarf_index(reg: u16) -> gimli::Register {
-    static DWARF_GPR: [gimli::Register; 16] = [
-        X86_64::RAX,
-        X86_64::RDX,
-        X86_64::RCX,
-        X86_64::RBX,
-        X86_64::RSI,
-        X86_64::RDI,
-        X86_64::RBP,
-        X86_64::RSP,
-        X86_64::R8,
-        X86_64::R9,
-        X86_64::R10,
-        X86_64::R11,
-        X86_64::R12,
-        X86_64::R13,
-        X86_64::R14,
-        X86_64::R15,
-    ];
-    static DWARF_XMM: [gimli::Register; 16] = [
-        X86_64::XMM0,
-        X86_64::XMM1,
-        X86_64::XMM2,
-        X86_64::XMM3,
-        X86_64::XMM4,
-        X86_64::XMM5,
-        X86_64::XMM6,
-        X86_64::XMM7,
-        X86_64::XMM8,
-        X86_64::XMM9,
-        X86_64::XMM10,
-        X86_64::XMM11,
-        X86_64::XMM12,
-        X86_64::XMM13,
-        X86_64::XMM14,
-        X86_64::XMM15,
-    ];
-    match reg {
-        0..=15 => DWARF_GPR[reg as usize],
-        17..=24 => DWARF_XMM[reg as usize - 17],
-        _ => panic!("Unknown register index {}", reg),
-    }
-}
-
 pub struct MachineX86_64 {
     assembler: AssemblerX64,
     used_gprs: u32,
@@ -135,9 +100,13 @@ pub struct MachineX86_64 {
     /// The source location for the current operator.
     src_loc: u32,
     /// Vector of unwind operations with offset
-    unwind_ops: Vec<(usize, UnwindOps)>,
+    unwind_ops: Vec<(usize, UnwindOps<GPR, XMM>)>,
 }
 
+/// Get registers for first N function return values.
+/// NOTE: The register set must be disjoint from pick_gpr registers!
+pub(crate) const X86_64_RETURN_VALUE_REGISTERS: [GPR; 2] = [GPR::RAX, GPR::RDX];
+
 impl MachineX86_64 {
     pub fn new(target: Option<Target>) -> Result<Self, CompileError> {
         let assembler = AssemblerX64::new(0, target)?;
@@ -675,7 +644,7 @@ impl MachineX86_64 {
             },
         )?;
 
-        self.jmp_on_different(retry)?;
+        self.assembler.emit_jmp(Condition::NotEqual, retry)?;
 
         self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
         self.release_gpr(compare);
@@ -1105,7 +1074,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 +1225,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 +1317,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 +1413,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 +1487,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 +1638,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 +1717,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 +1800,7 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::u32::MAX),
+                    Location::Imm32(u32::MAX),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1916,7 +1885,7 @@ impl MachineX86_64 {
         self.used_simd &= !(1 << r.into_index());
         ret
     }
-    fn emit_unwind_op(&mut self, op: UnwindOps) -> Result<(), CompileError> {
+    fn emit_unwind_op(&mut self, op: UnwindOps<GPR, XMM>) -> Result<(), CompileError> {
         self.unwind_ops.push((self.get_offset().0, op));
         Ok(())
     }
@@ -1924,6 +1893,75 @@ impl MachineX86_64 {
         let v = trap as u8;
         self.assembler.emit_ud1_payload(v)
     }
+
+    // logic
+    fn location_xor(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_xor(size, source, dest)
+    }
+    fn location_or(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_or(size, source, dest)
+    }
+    fn load_address(
+        &mut self,
+        size: Size,
+        reg: Location,
+        mem: Location,
+    ) -> Result<(), CompileError> {
+        match reg {
+            Location::GPR(_) => {
+                match mem {
+                    Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                        // Memory moves with size < 32b do not zero upper bits.
+                        if size < Size::S32 {
+                            self.assembler.emit_xor(Size::S32, reg, reg)?;
+                        }
+                        self.assembler.emit_mov(size, mem, reg)?;
+                    }
+                    _ => codegen_error!("singlepass load_address unreachable"),
+                }
+            }
+            _ => codegen_error!("singlepass load_address unreachable"),
+        }
+        Ok(())
+    }
+
+    fn location_neg(
+        &mut self,
+        size_val: Size, // size of src
+        signed: bool,
+        source: Location,
+        size_op: Size,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.move_location_extend(size_val, signed, source, size_op, dest)?;
+        self.assembler.emit_neg(size_val, dest)
+    }
+
+    fn emit_relaxed_zero_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        if (sz_src == Size::S32 || sz_src == Size::S64) && sz_dst == Size::S64 {
+            self.emit_relaxed_binop(AssemblerX64::emit_mov, sz_src, src, dst)
+        } else {
+            self.emit_relaxed_zx_sx(AssemblerX64::emit_movzx, sz_src, src, sz_dst, dst)
+        }
+    }
 }
 
 impl Machine for MachineX86_64 {
@@ -1932,12 +1970,6 @@ impl Machine for MachineX86_64 {
     fn assembler_get_offset(&self) -> Offset {
         self.assembler.get_offset()
     }
-    fn index_from_gpr(&self, x: GPR) -> RegisterIndex {
-        RegisterIndex(x as usize)
-    }
-    fn index_from_simd(&self, x: XMM) -> RegisterIndex {
-        RegisterIndex(x as usize + 16)
-    }
 
     fn get_vmctx_reg(&self) -> GPR {
         GPR::R15
@@ -1959,7 +1991,7 @@ impl Machine for MachineX86_64 {
 
     fn pick_gpr(&self) -> Option<GPR> {
         use GPR::*;
-        static REGS: &[GPR] = &[RSI, RDI, R8, R9, R10, R11];
+        static REGS: &[GPR] = &[R8, R9, R10, R11];
         for r in REGS {
             if !self.used_gprs_contains(r) {
                 return Some(*r);
@@ -1971,7 +2003,7 @@ impl Machine for MachineX86_64 {
     // Picks an unused general purpose register for internal temporary use.
     fn pick_temp_gpr(&self) -> Option<GPR> {
         use GPR::*;
-        static REGS: &[GPR] = &[RAX, RCX, RDX];
+        static REGS: &[GPR] = &[RAX, RCX, RDX, RDI, RSI];
         for r in REGS {
             if !self.used_gprs_contains(r) {
                 return Some(*r);
@@ -2058,7 +2090,7 @@ impl Machine for MachineX86_64 {
     }
 
     fn push_used_simd(&mut self, used_xmms: &[XMM]) -> Result<usize, CompileError> {
-        self.adjust_stack((used_xmms.len() * 8) as u32)?;
+        self.extend_stack((used_xmms.len() * 8) as u32)?;
 
         for (i, r) in used_xmms.iter().enumerate() {
             self.move_location(
@@ -2155,29 +2187,22 @@ impl Machine for MachineX86_64 {
         value
     }
 
-    // Adjust stack for locals
-    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+    fn extend_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
         self.assembler.emit_sub(
             Size::S64,
             Location::Imm32(delta_stack_offset),
             Location::GPR(GPR::RSP),
         )
     }
-    // restore stack
-    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
-        self.assembler.emit_add(
-            Size::S64,
-            Location::Imm32(delta_stack_offset),
-            Location::GPR(GPR::RSP),
-        )
-    }
-    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+
+    fn truncate_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
         self.assembler.emit_add(
             Size::S64,
             Location::Imm32(delta_stack_offset),
             Location::GPR(GPR::RSP),
         )
     }
+
     // push a value on the stack for a native call
     fn move_location_for_native(
         &mut self,
@@ -2239,11 +2264,11 @@ impl Machine for MachineX86_64 {
         )?;
         match location {
             Location::GPR(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
-                reg: x.to_dwarf(),
+                reg: UnwindRegister::GPR(x),
                 bp_neg_offset: stack_offset,
             }),
             Location::SIMD(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
-                reg: x.to_dwarf(),
+                reg: UnwindRegister::FPR(x),
                 bp_neg_offset: stack_offset,
             }),
             _ => Ok(()),
@@ -2260,6 +2285,14 @@ impl Machine for MachineX86_64 {
         }
     }
 
+    /// Get registers for first N function call parameters.
+    fn get_param_registers(&self, calling_convention: CallingConvention) -> &'static [Self::GPR] {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => &[GPR::RCX, GPR::RDX, GPR::R8, GPR::R9],
+            _ => &[GPR::RDI, GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9],
+        }
+    }
+
     // Get param location
     fn get_param_location(
         &self,
@@ -2268,85 +2301,102 @@ impl Machine for MachineX86_64 {
         stack_location: &mut usize,
         calling_convention: CallingConvention,
     ) -> Location {
-        match calling_convention {
-            CallingConvention::WindowsFastcall => match idx {
-                0 => Location::GPR(GPR::RCX),
-                1 => Location::GPR(GPR::RDX),
-                2 => Location::GPR(GPR::R8),
-                3 => Location::GPR(GPR::R9),
-                _ => {
-                    let loc = Location::Memory(GPR::RSP, *stack_location as i32);
-                    *stack_location += 8;
-                    loc
-                }
-            },
-            _ => match idx {
-                0 => Location::GPR(GPR::RDI),
-                1 => Location::GPR(GPR::RSI),
-                2 => Location::GPR(GPR::RDX),
-                3 => Location::GPR(GPR::RCX),
-                4 => Location::GPR(GPR::R8),
-                5 => Location::GPR(GPR::R9),
-                _ => {
+        self.get_param_registers(calling_convention)
+            .get(idx)
+            .map_or_else(
+                || {
                     let loc = Location::Memory(GPR::RSP, *stack_location as i32);
                     *stack_location += 8;
                     loc
-                }
-            },
-        }
+                },
+                |reg| Location::GPR(*reg),
+            )
     }
     // Get call param location
     fn get_call_param_location(
         &self,
+        return_slots: usize,
         idx: usize,
         _sz: Size,
         _stack_location: &mut usize,
         calling_convention: CallingConvention,
     ) -> Location {
+        let register_params = self.get_param_registers(calling_convention);
+        let return_values_memory_size =
+            8 * return_slots.saturating_sub(X86_64_RETURN_VALUE_REGISTERS.len());
         match calling_convention {
-            CallingConvention::WindowsFastcall => match idx {
-                0 => Location::GPR(GPR::RCX),
-                1 => Location::GPR(GPR::RDX),
-                2 => Location::GPR(GPR::R8),
-                3 => Location::GPR(GPR::R9),
-                _ => Location::Memory(GPR::RBP, (32 + 16 + (idx - 4) * 8) as i32),
-            },
-            _ => match idx {
-                0 => Location::GPR(GPR::RDI),
-                1 => Location::GPR(GPR::RSI),
-                2 => Location::GPR(GPR::RDX),
-                3 => Location::GPR(GPR::RCX),
-                4 => Location::GPR(GPR::R8),
-                5 => Location::GPR(GPR::R9),
-                _ => Location::Memory(GPR::RBP, (16 + (idx - 6) * 8) as i32),
-            },
+            CallingConvention::WindowsFastcall => register_params.get(idx).map_or_else(
+                || {
+                    Location::Memory(
+                        GPR::RBP,
+                        (32 + 16 + return_values_memory_size + (idx - register_params.len()) * 8)
+                            as i32,
+                    )
+                },
+                |reg| Location::GPR(*reg),
+            ),
+            _ => register_params.get(idx).map_or_else(
+                || {
+                    Location::Memory(
+                        GPR::RBP,
+                        (16 + return_values_memory_size + (idx - register_params.len()) * 8) as i32,
+                    )
+                },
+                |reg| Location::GPR(*reg),
+            ),
         }
     }
-    // Get simple param location
+
     fn get_simple_param_location(
         &self,
         idx: usize,
         calling_convention: CallingConvention,
+    ) -> Self::GPR {
+        self.get_param_registers(calling_convention)[idx]
+    }
+
+    /// Get return value location (to build a call, using SP for stack return values).
+    fn get_return_value_location(
+        &self,
+        idx: usize,
+        stack_location: &mut usize,
+        calling_convention: CallingConvention,
     ) -> Location {
-        match calling_convention {
-            CallingConvention::WindowsFastcall => match idx {
-                0 => Location::GPR(GPR::RCX),
-                1 => Location::GPR(GPR::RDX),
-                2 => Location::GPR(GPR::R8),
-                3 => Location::GPR(GPR::R9),
-                _ => Location::Memory(GPR::RBP, (32 + 16 + (idx - 4) * 8) as i32),
+        X86_64_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                let stack_padding = match calling_convention {
+                    CallingConvention::WindowsFastcall => 32,
+                    _ => 0,
+                };
+                let loc = Location::Memory(GPR::RSP, *stack_location as i32 + stack_padding);
+                *stack_location += 8;
+                loc
             },
-            _ => match idx {
-                0 => Location::GPR(GPR::RDI),
-                1 => Location::GPR(GPR::RSI),
-                2 => Location::GPR(GPR::RDX),
-                3 => Location::GPR(GPR::RCX),
-                4 => Location::GPR(GPR::R8),
-                5 => Location::GPR(GPR::R9),
-                _ => Location::Memory(GPR::RBP, (16 + (idx - 6) * 8) as i32),
+            |reg| Location::GPR(*reg),
+        )
+    }
+
+    /// Get return value location (from a call, using FP for stack return values).
+    fn get_call_return_value_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        X86_64_RETURN_VALUE_REGISTERS.get(idx).map_or_else(
+            || {
+                let stack_padding = match calling_convention {
+                    CallingConvention::WindowsFastcall => 32,
+                    _ => 0,
+                };
+                Location::Memory(
+                    GPR::RBP,
+                    (16 + stack_padding + (idx - X86_64_RETURN_VALUE_REGISTERS.len()) * 8) as i32,
+                )
             },
-        }
+            |reg| Location::GPR(*reg),
+        )
     }
+
     // move a location to another
     fn move_location(
         &mut self,
@@ -2427,8 +2477,7 @@ impl Machine for MachineX86_64 {
                 }
             },
             _ => panic!(
-                "unimplemented move_location_extend({:?}, {}, {:?}, {:?}, {:?}",
-                size_val, signed, source, size_op, dest
+                "unimplemented move_location_extend({size_val:?}, {signed}, {source:?}, {size_op:?}, {dest:?}"
             ),
         }?;
         if dst != dest {
@@ -2440,29 +2489,7 @@ impl Machine for MachineX86_64 {
         }
         Ok(())
     }
-    fn load_address(
-        &mut self,
-        size: Size,
-        reg: Location,
-        mem: Location,
-    ) -> Result<(), CompileError> {
-        match reg {
-            Location::GPR(_) => {
-                match mem {
-                    Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
-                        // Memory moves with size < 32b do not zero upper bits.
-                        if size < Size::S32 {
-                            self.assembler.emit_xor(Size::S32, reg, reg)?;
-                        }
-                        self.assembler.emit_mov(size, mem, reg)?;
-                    }
-                    _ => codegen_error!("singlepass load_address unreachable"),
-                }
-            }
-            _ => codegen_error!("singlepass load_address unreachable"),
-        }
-        Ok(())
-    }
+
     // Init the stack loc counter
     fn init_stack_loc(
         &mut self,
@@ -2493,15 +2520,17 @@ impl Machine for MachineX86_64 {
     fn pop_location(&mut self, location: Location) -> Result<(), CompileError> {
         self.assembler.emit_pop(Size::S64, location)
     }
-    // Create a new `MachineState` with default values.
-    fn new_machine_state(&self) -> MachineState {
-        new_machine_state()
-    }
 
     // assembler finalize
-    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
-        self.assembler.finalize().map_err(|e| {
-            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+    fn assembler_finalize(
+        self,
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<FinalizedAssembly, CompileError> {
+        Ok(FinalizedAssembly {
+            body: self.assembler.finalize().map_err(|e| {
+                CompileError::Codegen(format!("Assembler failed finalization with: {e:?}"))
+            })?,
+            assembly_comments,
         })
     }
 
@@ -2526,27 +2555,6 @@ impl Machine for MachineX86_64 {
         self.emit_pop(Size::S64, Location::GPR(GPR::RBP))
     }
 
-    fn emit_function_return_value(
-        &mut self,
-        ty: WpType,
-        canonicalize: bool,
-        loc: Location,
-    ) -> Result<(), CompileError> {
-        if canonicalize {
-            self.canonicalize_nan(
-                match ty {
-                    WpType::F32 => Size::S32,
-                    WpType::F64 => Size::S64,
-                    _ => codegen_error!("singlepass emit_function_return_value unreachable"),
-                },
-                loc,
-                Location::GPR(GPR::RAX),
-            )
-        } else {
-            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(GPR::RAX))
-        }
-    }
-
     fn emit_function_return_float(&mut self) -> Result<(), CompileError> {
         self.move_location(
             Size::S64,
@@ -2555,9 +2563,6 @@ impl Machine for MachineX86_64 {
         )
     }
 
-    fn arch_supports_canonicalize_nan(&self) -> bool {
-        self.assembler.arch_supports_canonicalize_nan()
-    }
     fn canonicalize_nan(
         &mut self,
         sz: Size,
@@ -2640,7 +2645,7 @@ impl Machine for MachineX86_64 {
     fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_label(label)
     }
-    fn get_grp_for_call(&self) -> GPR {
+    fn get_gpr_for_call(&self) -> GPR {
         GPR::RAX
     }
     fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
@@ -2649,16 +2654,6 @@ impl Machine for MachineX86_64 {
     fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_call_label(label)
     }
-    fn get_gpr_for_ret(&self) -> GPR {
-        GPR::RAX
-    }
-    fn get_simd_for_ret(&self) -> XMM {
-        XMM::XMM0
-    }
-
-    fn arch_requires_indirect_call_trampoline(&self) -> bool {
-        self.assembler.arch_requires_indirect_call_trampoline()
-    }
 
     fn arch_emit_indirect_call_with_trampoline(
         &mut self,
@@ -2675,52 +2670,6 @@ impl Machine for MachineX86_64 {
     fn emit_call_location(&mut self, location: Location) -> Result<(), CompileError> {
         self.assembler.emit_call_location(location)
     }
-
-    fn location_address(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_lea(size, source, dest)
-    }
-    // logic
-    fn location_and(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_and(size, source, dest)
-    }
-    fn location_xor(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_xor(size, source, dest)
-    }
-    fn location_or(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_or(size, source, dest)
-    }
-    fn location_test(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_test(size, source, dest)
-    }
-    // math
     fn location_add(
         &mut self,
         size: Size,
@@ -2730,15 +2679,6 @@ impl Machine for MachineX86_64 {
     ) -> Result<(), CompileError> {
         self.assembler.emit_add(size, source, dest)
     }
-    fn location_sub(
-        &mut self,
-        size: Size,
-        source: Location,
-        dest: Location,
-        _flags: bool,
-    ) -> Result<(), CompileError> {
-        self.assembler.emit_sub(size, source, dest)
-    }
     fn location_cmp(
         &mut self,
         size: Size,
@@ -2747,28 +2687,30 @@ impl Machine for MachineX86_64 {
     ) -> Result<(), CompileError> {
         self.assembler.emit_cmp(size, source, dest)
     }
-    // (un)conditionnal jmp
-    // (un)conditionnal jmp
-    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError> {
+
+    // unconditional jmp
+    fn jmp_unconditional(&mut self, label: Label) -> Result<(), CompileError> {
         self.assembler.emit_jmp(Condition::None, label)
     }
-    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::Equal, label)
-    }
-    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::NotEqual, label)
-    }
-    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::Above, label)
-    }
-    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::AboveEqual, label)
-    }
-    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::BelowEqual, label)
-    }
-    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError> {
-        self.assembler.emit_jmp(Condition::Carry, label)
+
+    fn jmp_on_condition(
+        &mut self,
+        cond: UnsignedCondition,
+        size: Size,
+        loc_a: AbstractLocation<Self::GPR, Self::SIMD>,
+        loc_b: AbstractLocation<Self::GPR, Self::SIMD>,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_cmp(size, loc_b, loc_a)?;
+        let cond = match cond {
+            UnsignedCondition::Equal => Condition::Equal,
+            UnsignedCondition::NotEqual => Condition::NotEqual,
+            UnsignedCondition::Above => Condition::Above,
+            UnsignedCondition::AboveEqual => Condition::AboveEqual,
+            UnsignedCondition::Below => Condition::Below,
+            UnsignedCondition::BelowEqual => Condition::BelowEqual,
+        };
+        self.assembler.emit_jmp(cond, label)
     }
 
     // jmp table
@@ -2826,18 +2768,6 @@ impl Machine for MachineX86_64 {
         Ok(())
     }
 
-    fn location_neg(
-        &mut self,
-        size_val: Size, // size of src
-        signed: bool,
-        source: Location,
-        size_op: Size,
-        dest: Location,
-    ) -> Result<(), CompileError> {
-        self.move_location_extend(size_val, signed, source, size_op, dest)?;
-        self.assembler.emit_neg(size_val, dest)
-    }
-
     fn emit_imul_imm32(&mut self, size: Size, imm32: u32, gpr: GPR) -> Result<(), CompileError> {
         match size {
             Size::S64 => self.assembler.emit_imul_imm32_gpr64(imm32, gpr),
@@ -2864,19 +2794,7 @@ impl Machine for MachineX86_64 {
     ) -> Result<(), CompileError> {
         self.emit_relaxed_binop(AssemblerX64::emit_cmp, sz, src, dst)
     }
-    fn emit_relaxed_zero_extension(
-        &mut self,
-        sz_src: Size,
-        src: Location,
-        sz_dst: Size,
-        dst: Location,
-    ) -> Result<(), CompileError> {
-        if (sz_src == Size::S32 || sz_src == Size::S64) && sz_dst == Size::S64 {
-            self.emit_relaxed_binop(AssemblerX64::emit_mov, sz_src, src, dst)
-        } else {
-            self.emit_relaxed_zx_sx(AssemblerX64::emit_movzx, sz_src, src, sz_dst, dst)
-        }
-    }
+
     fn emit_relaxed_sign_extension(
         &mut self,
         sz_src: Size,
@@ -2917,7 +2835,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         self.assembler
@@ -2962,7 +2879,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         self.assembler
@@ -2985,7 +2901,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         let normal_path = self.assembler.get_label();
@@ -4586,7 +4501,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         self.assembler
@@ -4631,7 +4545,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         self.assembler
@@ -4654,7 +4567,6 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
         integer_division_by_zero: Label,
-        _integer_overflow: Label,
     ) -> Result<usize, CompileError> {
         // We assume that RAX and RDX are temporary registers here.
         let normal_path = self.assembler.get_label();
@@ -6657,7 +6569,6 @@ impl Machine for MachineX86_64 {
         heap_access_oob: Label,
         unaligned_atomic: Label,
     ) -> Result<(), CompileError> {
-        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
         self.memory_op(
             target_addr,
             memarg,
@@ -6725,7 +6636,6 @@ impl Machine for MachineX86_64 {
         heap_access_oob: Label,
         unaligned_atomic: Label,
     ) -> Result<(), CompileError> {
-        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
         self.memory_op(
             target_addr,
             memarg,
@@ -7153,126 +7063,119 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
     ) -> Result<(), CompileError> {
-        if !self.arch_supports_canonicalize_nan() {
-            self.emit_relaxed_avx(AssemblerX64::emit_vminsd, loc_a, loc_b, ret)
-        } else {
-            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
-            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
+        // Canonicalize the result to differentiate arithmetic NaNs from canonical NaNs.
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
 
-            let src1 = match loc_a {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                _ => {
-                    codegen_error!("singlepass f64_min unreachable");
-                }
-            };
-            let src2 = match loc_b {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                _ => {
-                    codegen_error!("singlepass f64_min unreachable");
-                }
-            };
+        let src1 = match loc_a {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            _ => {
+                codegen_error!("singlepass f64_min unreachable");
+            }
+        };
+        let src2 = match loc_b {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            _ => {
+                codegen_error!("singlepass f64_min unreachable");
+            }
+        };
 
-            let tmp_xmm1 = XMM::XMM8;
-            let tmp_xmm2 = XMM::XMM9;
-            let tmp_xmm3 = XMM::XMM10;
+        let tmp_xmm1 = XMM::XMM8;
+        let tmp_xmm2 = XMM::XMM9;
+        let tmp_xmm3 = XMM::XMM10;
 
-            self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
-            self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
-            self.assembler
-                .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
-            self.assembler
-                .emit_vminsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
-            let label1 = self.assembler.get_label();
-            let label2 = self.assembler.get_label();
-            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
-            self.assembler
-                .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
-            self.assembler.emit_jmp(Condition::None, label2)?;
-            self.emit_label(label1)?;
-            // load float -0.0
-            self.move_location(
-                Size::S64,
-                Location::Imm64(0x8000_0000_0000_0000), // Negative zero
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
-            self.emit_label(label2)?;
-            self.assembler
-                .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
-            self.assembler.emit_vblendvpd(
-                tmp_xmm3,
-                XMMOrMemory::XMM(tmp_xmm2),
-                tmp_xmm1,
-                tmp_xmm1,
-            )?;
-            self.assembler
-                .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
-            // load float canonical nan
-            self.move_location(
-                Size::S64,
-                Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
-            self.assembler
-                .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
-            match ret {
-                Location::SIMD(x) => {
-                    self.assembler
-                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
-                }
-                Location::Memory(_, _) | Location::GPR(_) => {
-                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
-                }
-                _ => {
-                    codegen_error!("singlepass f64_min unreachable");
-                }
+        self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
+        self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
+        self.assembler
+            .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+        self.assembler
+            .emit_vminsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+        let label1 = self.assembler.get_label();
+        let label2 = self.assembler.get_label();
+        self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+        self.assembler
+            .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+        self.assembler.emit_jmp(Condition::None, label2)?;
+        self.emit_label(label1)?;
+        // load float -0.0
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x8000_0000_0000_0000), // Negative zero
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
+        self.emit_label(label2)?;
+        self.assembler
+            .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+        self.assembler
+            .emit_vblendvpd(tmp_xmm3, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm1, tmp_xmm1)?;
+        self.assembler
+            .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
+        // load float canonical nan
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+        self.assembler
+            .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+        match ret {
+            Location::SIMD(x) => {
+                self.assembler
+                    .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+            }
+            _ => {
+                codegen_error!("singlepass f64_min unreachable");
             }
-
-            self.release_gpr(tmpg2);
-            self.release_gpr(tmpg1);
-            self.release_simd(tmp2);
-            self.release_simd(tmp1);
-            Ok(())
         }
+
+        self.release_gpr(tmpg2);
+        self.release_gpr(tmpg1);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
     }
     fn f64_max(
         &mut self,
@@ -7280,121 +7183,114 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
     ) -> Result<(), CompileError> {
-        if !self.arch_supports_canonicalize_nan() {
-            self.emit_relaxed_avx(AssemblerX64::emit_vmaxsd, loc_a, loc_b, ret)
-        } else {
-            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
-            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
+        // Canonicalize the result to differentiate arithmetic NaNs from canonical NaNs.
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
 
-            let src1 = match loc_a {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                _ => {
-                    codegen_error!("singlepass f64_max unreachable");
-                }
-            };
-            let src2 = match loc_b {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                _ => {
-                    codegen_error!("singlepass f64_max unreachable");
-                }
-            };
+        let src1 = match loc_a {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            _ => {
+                codegen_error!("singlepass f64_max unreachable");
+            }
+        };
+        let src2 = match loc_b {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            _ => {
+                codegen_error!("singlepass f64_max unreachable");
+            }
+        };
 
-            let tmp_xmm1 = XMM::XMM8;
-            let tmp_xmm2 = XMM::XMM9;
-            let tmp_xmm3 = XMM::XMM10;
+        let tmp_xmm1 = XMM::XMM8;
+        let tmp_xmm2 = XMM::XMM9;
+        let tmp_xmm3 = XMM::XMM10;
 
-            self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
-            self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
-            self.assembler
-                .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
-            self.assembler
-                .emit_vmaxsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
-            let label1 = self.assembler.get_label();
-            let label2 = self.assembler.get_label();
-            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
-            self.assembler
-                .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
-            self.assembler.emit_jmp(Condition::None, label2)?;
-            self.emit_label(label1)?;
-            self.assembler
-                .emit_vxorpd(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
-            self.emit_label(label2)?;
-            self.assembler
-                .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
-            self.assembler.emit_vblendvpd(
-                tmp_xmm3,
-                XMMOrMemory::XMM(tmp_xmm2),
-                tmp_xmm1,
-                tmp_xmm1,
-            )?;
-            self.assembler
-                .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
-            // load float canonical nan
-            self.move_location(
-                Size::S64,
-                Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
-            self.assembler
-                .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
-            match ret {
-                Location::SIMD(x) => {
-                    self.assembler
-                        .emit_vmovapd(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
-                }
-                Location::Memory(_, _) | Location::GPR(_) => {
-                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
-                }
-                _ => {
-                    codegen_error!("singlepass f64_max unreachable");
-                }
+        self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
+        self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
+        self.assembler
+            .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+        self.assembler
+            .emit_vmaxsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+        let label1 = self.assembler.get_label();
+        let label2 = self.assembler.get_label();
+        self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+        self.assembler
+            .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+        self.assembler.emit_jmp(Condition::None, label2)?;
+        self.emit_label(label1)?;
+        self.assembler
+            .emit_vxorpd(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
+        self.emit_label(label2)?;
+        self.assembler
+            .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+        self.assembler
+            .emit_vblendvpd(tmp_xmm3, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm1, tmp_xmm1)?;
+        self.assembler
+            .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
+        // load float canonical nan
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+        self.assembler
+            .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+        match ret {
+            Location::SIMD(x) => {
+                self.assembler
+                    .emit_vmovapd(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+            }
+            _ => {
+                codegen_error!("singlepass f64_max unreachable");
             }
-
-            self.release_gpr(tmpg2);
-            self.release_gpr(tmpg1);
-            self.release_simd(tmp2);
-            self.release_simd(tmp1);
-            Ok(())
         }
+
+        self.release_gpr(tmpg2);
+        self.release_gpr(tmpg1);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
     }
     fn f64_add(
         &mut self,
@@ -7551,126 +7447,119 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
     ) -> Result<(), CompileError> {
-        if !self.arch_supports_canonicalize_nan() {
-            self.emit_relaxed_avx(AssemblerX64::emit_vminss, loc_a, loc_b, ret)
-        } else {
-            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
-            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
+        // Canonicalize the result to differentiate arithmetic NaNs from canonical NaNs.
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
 
-            let src1 = match loc_a {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                _ => {
-                    codegen_error!("singlepass f32_min unreachable");
-                }
-            };
-            let src2 = match loc_b {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                _ => {
-                    codegen_error!("singlepass f32_min unreachable");
-                }
-            };
+        let src1 = match loc_a {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            _ => {
+                codegen_error!("singlepass f32_min unreachable");
+            }
+        };
+        let src2 = match loc_b {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            _ => {
+                codegen_error!("singlepass f32_min unreachable");
+            }
+        };
 
-            let tmp_xmm1 = XMM::XMM8;
-            let tmp_xmm2 = XMM::XMM9;
-            let tmp_xmm3 = XMM::XMM10;
+        let tmp_xmm1 = XMM::XMM8;
+        let tmp_xmm2 = XMM::XMM9;
+        let tmp_xmm3 = XMM::XMM10;
 
-            self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
-            self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
-            self.assembler
-                .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
-            self.assembler
-                .emit_vminss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
-            let label1 = self.assembler.get_label();
-            let label2 = self.assembler.get_label();
-            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
-            self.assembler
-                .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
-            self.assembler.emit_jmp(Condition::None, label2)?;
-            self.emit_label(label1)?;
-            // load float -0.0
-            self.move_location(
-                Size::S64,
-                Location::Imm32(0x8000_0000), // Negative zero
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
-            self.emit_label(label2)?;
-            self.assembler
-                .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
-            self.assembler.emit_vblendvps(
-                tmp_xmm3,
-                XMMOrMemory::XMM(tmp_xmm2),
-                tmp_xmm1,
-                tmp_xmm1,
-            )?;
-            self.assembler
-                .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
-            // load float canonical nan
-            self.move_location(
-                Size::S64,
-                Location::Imm32(0x7FC0_0000), // Canonical NaN
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
-            self.assembler
-                .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
-            match ret {
-                Location::SIMD(x) => {
-                    self.assembler
-                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
-                }
-                Location::Memory(_, _) | Location::GPR(_) => {
-                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
-                }
-                _ => {
-                    codegen_error!("singlepass f32_min unreachable");
-                }
+        self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
+        self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+        self.assembler
+            .emit_vminss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+        let label1 = self.assembler.get_label();
+        let label2 = self.assembler.get_label();
+        self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+        self.assembler
+            .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+        self.assembler.emit_jmp(Condition::None, label2)?;
+        self.emit_label(label1)?;
+        // load float -0.0
+        self.move_location(
+            Size::S64,
+            Location::Imm32(0x8000_0000), // Negative zero
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
+        self.emit_label(label2)?;
+        self.assembler
+            .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+        self.assembler
+            .emit_vblendvps(tmp_xmm3, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm1, tmp_xmm1)?;
+        self.assembler
+            .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
+        // load float canonical nan
+        self.move_location(
+            Size::S64,
+            Location::Imm32(0x7FC0_0000), // Canonical NaN
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+        self.assembler
+            .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+        match ret {
+            Location::SIMD(x) => {
+                self.assembler
+                    .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+            }
+            _ => {
+                codegen_error!("singlepass f32_min unreachable");
             }
-
-            self.release_gpr(tmpg2);
-            self.release_gpr(tmpg1);
-            self.release_simd(tmp2);
-            self.release_simd(tmp1);
-            Ok(())
         }
+
+        self.release_gpr(tmpg2);
+        self.release_gpr(tmpg1);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
     }
     fn f32_max(
         &mut self,
@@ -7678,121 +7567,114 @@ impl Machine for MachineX86_64 {
         loc_b: Location,
         ret: Location,
     ) -> Result<(), CompileError> {
-        if !self.arch_supports_canonicalize_nan() {
-            self.emit_relaxed_avx(AssemblerX64::emit_vmaxss, loc_a, loc_b, ret)
-        } else {
-            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
-            })?;
-            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
-            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
-                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
-            })?;
+        // Canonicalize the result to differentiate arithmetic NaNs from canonical NaNs.
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
 
-            let src1 = match loc_a {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
-                    tmp1
-                }
-                _ => {
-                    codegen_error!("singlepass f32_max unreachable");
-                }
-            };
-            let src2 = match loc_b {
-                Location::SIMD(x) => x,
-                Location::GPR(_) | Location::Memory(_, _) => {
-                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm32(_) => {
-                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                Location::Imm64(_) => {
-                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
-                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
-                    tmp2
-                }
-                _ => {
-                    codegen_error!("singlepass f32_max unreachable");
-                }
-            };
+        let src1 = match loc_a {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            _ => {
+                codegen_error!("singlepass f32_max unreachable");
+            }
+        };
+        let src2 = match loc_b {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm32(_) => {
+                self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            Location::Imm64(_) => {
+                self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                tmp2
+            }
+            _ => {
+                codegen_error!("singlepass f32_max unreachable");
+            }
+        };
 
-            let tmp_xmm1 = XMM::XMM8;
-            let tmp_xmm2 = XMM::XMM9;
-            let tmp_xmm3 = XMM::XMM10;
+        let tmp_xmm1 = XMM::XMM8;
+        let tmp_xmm2 = XMM::XMM9;
+        let tmp_xmm3 = XMM::XMM10;
 
-            self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
-            self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
-            self.assembler
-                .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
-            self.assembler
-                .emit_vmaxss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
-            let label1 = self.assembler.get_label();
-            let label2 = self.assembler.get_label();
-            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
-            self.assembler
-                .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
-            self.assembler.emit_jmp(Condition::None, label2)?;
-            self.emit_label(label1)?;
-            self.assembler
-                .emit_vxorps(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
-            self.emit_label(label2)?;
-            self.assembler
-                .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
-            self.assembler.emit_vblendvps(
-                tmp_xmm3,
-                XMMOrMemory::XMM(tmp_xmm2),
-                tmp_xmm1,
-                tmp_xmm1,
-            )?;
-            self.assembler
-                .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
-            // load float canonical nan
-            self.move_location(
-                Size::S64,
-                Location::Imm32(0x7FC0_0000), // Canonical NaN
-                Location::GPR(tmpg1),
-            )?;
-            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
-            self.assembler
-                .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
-            match ret {
-                Location::SIMD(x) => {
-                    self.assembler
-                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
-                }
-                Location::Memory(_, _) | Location::GPR(_) => {
-                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
-                }
-                _ => {
-                    codegen_error!("singlepass f32_max unreachable");
-                }
+        self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
+        self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+        self.assembler
+            .emit_vmaxss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+        let label1 = self.assembler.get_label();
+        let label2 = self.assembler.get_label();
+        self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+        self.assembler
+            .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+        self.assembler.emit_jmp(Condition::None, label2)?;
+        self.emit_label(label1)?;
+        self.assembler
+            .emit_vxorps(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
+        self.emit_label(label2)?;
+        self.assembler
+            .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+        self.assembler
+            .emit_vblendvps(tmp_xmm3, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm1, tmp_xmm1)?;
+        self.assembler
+            .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
+        // load float canonical nan
+        self.move_location(
+            Size::S64,
+            Location::Imm32(0x7FC0_0000), // Canonical NaN
+            Location::GPR(tmpg1),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+        self.assembler
+            .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+        match ret {
+            Location::SIMD(x) => {
+                self.assembler
+                    .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+            }
+            _ => {
+                codegen_error!("singlepass f32_max unreachable");
             }
-
-            self.release_gpr(tmpg2);
-            self.release_gpr(tmpg1);
-            self.release_simd(tmp2);
-            self.release_simd(tmp1);
-            Ok(())
         }
+
+        self.release_gpr(tmpg2);
+        self.release_gpr(tmpg1);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
     }
     fn f32_add(
         &mut self,
@@ -7835,15 +7717,21 @@ impl Machine for MachineX86_64 {
         // the cpu feature here is irrelevant
         let mut a = AssemblerX64::new(0, None)?;
 
-        // Calculate stack offset.
-        let mut stack_offset: u32 = 0;
-        for (i, _param) in sig.params().iter().enumerate() {
-            if let Location::Memory(_, _) =
-                self.get_simple_param_location(1 + i, calling_convention)
-            {
-                stack_offset += 8;
-            }
-        }
+        // Calculate stack offset (+1 for the vmctx argument we are going to pass).
+        let stack_params = (0..sig.params().len() + 1)
+            .filter(|&i| {
+                self.get_param_registers(calling_convention)
+                    .get(i)
+                    .is_none()
+            })
+            .count();
+        let stack_return_slots = sig
+            .results()
+            .len()
+            .saturating_sub(X86_64_RETURN_VALUE_REGISTERS.len());
+
+        // Stack slots are not shared in between function params and return values.
+        let mut stack_offset = 8 * (stack_params + stack_return_slots) as u32;
         let stack_padding: u32 = match calling_convention {
             CallingConvention::WindowsFastcall => 32,
             _ => 0,
@@ -7868,28 +7756,28 @@ impl Machine for MachineX86_64 {
         // Arguments
         a.emit_mov(
             Size::S64,
-            self.get_simple_param_location(1, calling_convention),
+            Location::GPR(self.get_simple_param_location(1, calling_convention)),
             Location::GPR(GPR::R15),
         )?; // func_ptr
         a.emit_mov(
             Size::S64,
-            self.get_simple_param_location(2, calling_convention),
+            Location::GPR(self.get_simple_param_location(2, calling_convention)),
             Location::GPR(GPR::R14),
         )?; // args_rets
 
         // Move arguments to their locations.
         // `callee_vmctx` is already in the first argument register, so no need to move.
         {
-            let mut n_stack_args: usize = 0;
+            let mut n_stack_args = 0u32;
             for (i, _param) in sig.params().iter().enumerate() {
                 let src_loc = Location::Memory(GPR::R14, (i * 16) as _); // args_rets[i]
-                let dst_loc = self.get_simple_param_location(1 + i, calling_convention);
+                let dst_loc = self.get_param_registers(calling_convention).get(1 + i);
 
                 match dst_loc {
-                    Location::GPR(_) => {
-                        a.emit_mov(Size::S64, src_loc, dst_loc)?;
+                    Some(&gpr) => {
+                        a.emit_mov(Size::S64, src_loc, Location::GPR(gpr))?;
                     }
-                    Location::Memory(_, _) => {
+                    None => {
                         // This location is for reading arguments but we are writing arguments here.
                         // So recalculate it.
                         a.emit_mov(Size::S64, src_loc, Location::GPR(GPR::RAX))?;
@@ -7898,12 +7786,12 @@ impl Machine for MachineX86_64 {
                             Location::GPR(GPR::RAX),
                             Location::Memory(
                                 GPR::RSP,
-                                (stack_padding as usize + n_stack_args * 8) as _,
+                                (stack_padding + (n_stack_args + stack_return_slots as u32) * 8)
+                                    as _,
                             ),
                         )?;
                         n_stack_args += 1;
                     }
-                    _ => codegen_error!("singlepass gen_std_trampoline unreachable"),
                 }
             }
         }
@@ -7911,6 +7799,27 @@ impl Machine for MachineX86_64 {
         // Call.
         a.emit_call_location(Location::GPR(GPR::R15))?;
 
+        // Write return values.
+        let mut n_stack_return_slots: usize = 0;
+        for i in 0..sig.results().len() {
+            let src = if let Some(&reg) = X86_64_RETURN_VALUE_REGISTERS.get(i) {
+                Location::GPR(reg)
+            } else {
+                let loc = Location::GPR(GPR::R15);
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(
+                        GPR::RSP,
+                        (stack_padding + (n_stack_return_slots as u32 * 8)) as _,
+                    ),
+                    loc,
+                )?;
+                n_stack_return_slots += 1;
+                loc
+            };
+            a.emit_mov(Size::S64, src, Location::Memory(GPR::R14, (i * 16) as _))?;
+        }
+
         // Restore stack.
         a.emit_add(
             Size::S64,
@@ -7918,15 +7827,6 @@ impl Machine for MachineX86_64 {
             Location::GPR(GPR::RSP),
         )?;
 
-        // Write return value.
-        if !sig.results().is_empty() {
-            a.emit_mov(
-                Size::S64,
-                Location::GPR(GPR::RAX),
-                Location::Memory(GPR::R14, 0),
-            )?;
-        }
-
         // Restore callee-saved registers.
         a.emit_pop(Size::S64, Location::GPR(GPR::R14))?;
         a.emit_pop(Size::S64, Location::GPR(GPR::R15))?;
@@ -7935,6 +7835,7 @@ impl Machine for MachineX86_64 {
 
         let mut body = a.finalize().unwrap();
         body.shrink_to_fit();
+
         Ok(FunctionBody {
             body,
             unwind_info: None,
@@ -7970,7 +7871,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 +8007,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 +8052,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 +8132,7 @@ impl Machine for MachineX86_64 {
 
         Ok(CustomSection {
             protection: CustomSectionProtection::ReadExecute,
+            alignment: None,
             bytes: section_body,
             relocations: vec![],
         })
@@ -8259,9 +8161,9 @@ impl Machine for MachineX86_64 {
                 }
                 UnwindOps::SaveRegister { reg, bp_neg_offset } => instructions.push((
                     instruction_offset,
-                    CallFrameInstruction::Offset(dwarf_index(reg), -bp_neg_offset),
+                    CallFrameInstruction::Offset(reg.dwarf_index(), -bp_neg_offset),
                 )),
-                UnwindOps::Push2Regs { .. } => unimplemented!(),
+                UnwindOps::Push2Regs { .. } | UnwindOps::SubtractFP { .. } => unimplemented!(),
             }
         }
         Some(UnwindInstructions {
@@ -8298,7 +8200,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/riscv_decl.rs b/lib/compiler-singlepass/src/riscv_decl.rs
new file mode 100644
index 0000000000..6b796f3db8
--- /dev/null
+++ b/lib/compiler-singlepass/src/riscv_decl.rs
@@ -0,0 +1,438 @@
+//! RISC-V structures.
+
+use crate::location::{CombinedRegister, Reg as AbstractReg};
+use std::slice::Iter;
+use wasmer_types::{CompileError, Type};
+
+/*
+
+Register definition: https://en.wikichip.org/wiki/risc-v/registers#Calling_convention
+
++-----+-----------+-------------------------------+-------------------+
+| Reg | ABI Name  | Description                   | Saved by Callee   |
++-----+-----------+-------------------------------+-------------------+
+| x0  | zero      | hardwired zero                | -                 |
+| x1  | ra        | return address                | -R                |
+| x2  | sp        | stack pointer                 | -E                |
+| x3  | gp        | global pointer                | -                 |
+| x4  | tp        | thread pointer                | -                 |
+| x5  | t0        | temporary register 0          | -R                |
+| x6  | t1        | temporary register 1          | -R                |
+| x7  | t2        | temporary register 2          | -R                |
+| x8  | s0/fp     | saved register 0/frame pointer| -E                |
+| x9  | s1        | saved register 1              | -E                |
+| x10 | a0        | function arg 0/return value 0 | -R                |
+| x11 | a1        | function arg 1/return value 1 | -R                |
+| x12 | a2        | function argument 2           | -R                |
+| x13 | a3        | function argument 3           | -R                |
+| x14 | a4        | function argument 4           | -R                |
+| x15 | a5        | function argument 5           | -R                |
+| x16 | a6        | function argument 6           | -R                |
+| x17 | a7        | function argument 7           | -R                |
+| x18 | s2        | saved register 2              | -E                |
+| x19 | s3        | saved register 3              | -E                |
+| x20 | s4        | saved register 4              | -E                |
+| x21 | s5        | saved register 5              | -E                |
+| x22 | s6        | saved register 6              | -E                |
+| x23 | s7        | saved register 7              | -E                |
+| x24 | s8        | saved register 8              | -E                |
+| x25 | s9        | saved register 9              | -E                |
+| x26 | s10       | saved register 10             | -E                |
+| x27 | s11       | saved register 11             | -E                |
+| x28 | t3        | temporary register 3          | -R                |
+| x29 | t4        | temporary register 4          | -R                |
+| x30 | t5        | temporary register 5          | -R                |
+| x31 | t6        | temporary register 6          | -R                |
++-----+-----------+-------------------------------+-------------------+
+Legend: -R = caller-saved, -E = callee-saved, - = not saved
+*/
+
+/// General-purpose registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum GPR {
+    XZero = 0,
+    X1 = 1,
+    Sp = 2,
+    X3 = 3,
+    X4 = 4,
+    X5 = 5,
+    X6 = 6,
+    X7 = 7,
+    Fp = 8,
+    X9 = 9,
+    X10 = 10,
+    X11 = 11,
+    X12 = 12,
+    X13 = 13,
+    X14 = 14,
+    X15 = 15,
+    X16 = 16,
+    X17 = 17,
+    X18 = 18,
+    X19 = 19,
+    X20 = 20,
+    X21 = 21,
+    X22 = 22,
+    X23 = 23,
+    X24 = 24,
+    X25 = 25,
+    X26 = 26,
+    X27 = 27,
+    X28 = 28,
+    X29 = 29,
+    X30 = 30,
+    X31 = 31,
+}
+
+impl From<GPR> for u8 {
+    fn from(val: GPR) -> Self {
+        val as u8
+    }
+}
+
+impl AbstractReg for GPR {
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<GPR, ()> {
+        match n {
+            0..=31 => Ok(*GPR::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, GPR> {
+        static GPRS: [GPR; 32] = [
+            GPR::XZero,
+            GPR::X1,
+            GPR::Sp,
+            GPR::X3,
+            GPR::X4,
+            GPR::X5,
+            GPR::X6,
+            GPR::X7,
+            GPR::Fp,
+            GPR::X9,
+            GPR::X10,
+            GPR::X11,
+            GPR::X12,
+            GPR::X13,
+            GPR::X14,
+            GPR::X15,
+            GPR::X16,
+            GPR::X17,
+            GPR::X18,
+            GPR::X19,
+            GPR::X20,
+            GPR::X21,
+            GPR::X22,
+            GPR::X23,
+            GPR::X24,
+            GPR::X25,
+            GPR::X26,
+            GPR::X27,
+            GPR::X28,
+            GPR::X29,
+            GPR::X30,
+            GPR::X31,
+        ];
+        GPRS.iter()
+    }
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::RiscV;
+
+        match self {
+            GPR::XZero => RiscV::ZERO,
+            GPR::X1 => RiscV::X1,
+            GPR::Sp => RiscV::SP,
+            GPR::X3 => RiscV::X3,
+            GPR::X4 => RiscV::X4,
+            GPR::X5 => RiscV::X5,
+            GPR::X6 => RiscV::X6,
+            GPR::X7 => RiscV::X7,
+            // TODO: use new constant: https://github.com/gimli-rs/gimli/pull/802
+            GPR::Fp => RiscV::X8,
+            GPR::X9 => RiscV::X9,
+            GPR::X10 => RiscV::X10,
+            GPR::X11 => RiscV::X11,
+            GPR::X12 => RiscV::X12,
+            GPR::X13 => RiscV::X13,
+            GPR::X14 => RiscV::X14,
+            GPR::X15 => RiscV::X15,
+            GPR::X16 => RiscV::X16,
+            GPR::X17 => RiscV::X17,
+            GPR::X18 => RiscV::X18,
+            GPR::X19 => RiscV::X19,
+            GPR::X20 => RiscV::X20,
+            GPR::X21 => RiscV::X21,
+            GPR::X22 => RiscV::X22,
+            GPR::X23 => RiscV::X23,
+            GPR::X24 => RiscV::X24,
+            GPR::X25 => RiscV::X25,
+            GPR::X26 => RiscV::X26,
+            GPR::X27 => RiscV::X27,
+            GPR::X28 => RiscV::X28,
+            GPR::X29 => RiscV::X29,
+            GPR::X30 => RiscV::X30,
+            GPR::X31 => RiscV::X31,
+        }
+    }
+}
+
+/*
++-----+-------+--------------------------+-------------------+
+| Reg | Name  | Description              | Saved by          |
++-----+-------+--------------------------+-------------------+
+| f0  | ft0   | FP temporary             | Caller            |
+| f1  | ft1   | FP temporary             | Caller            |
+| f2  | ft2   | FP temporary             | Caller            |
+| f3  | ft3   | FP temporary             | Caller            |
+| f4  | ft4   | FP temporary             | Caller            |
+| f5  | ft5   | FP temporary             | Caller            |
+| f6  | ft6   | FP temporary             | Caller            |
+| f7  | ft7   | FP temporary             | Caller            |
+| f8  | fs0   | FP saved register        | Callee            |
+| f9  | fs1   | FP saved register        | Callee            |
+| f10 | fa0   | FP argument/return value | Caller            |
+| f11 | fa1   | FP argument/return value | Caller            |
+| f12 | fa2   | FP argument              | Caller            |
+| f13 | fa3   | FP argument              | Caller            |
+| f14 | fa4   | FP argument              | Caller            |
+| f15 | fa5   | FP argument              | Caller            |
+| f16 | fa6   | FP argument              | Caller            |
+| f17 | fa7   | FP argument              | Caller            |
+| f18 | fs2   | FP saved register        | Callee            |
+| f19 | fs3   | FP saved register        | Callee            |
+| f20 | fs4   | FP saved register        | Callee            |
+| f21 | fs5   | FP saved register        | Callee            |
+| f22 | fs6   | FP saved register        | Callee            |
+| f23 | fs7   | FP saved register        | Callee            |
+| f24 | fs8   | FP saved register        | Callee            |
+| f25 | fs9   | FP saved register        | Callee            |
+| f26 | fs10  | FP saved register        | Callee            |
+| f27 | fs11  | FP saved register        | Callee            |
+| f28 | ft8   | FP temporary             | Caller            |
+| f29 | ft9   | FP temporary             | Caller            |
+| f30 | ft10  | FP temporary             | Caller            |
+| f31 | ft11  | FP temporary             | Caller            |
++-----+-------+--------------------------+-------------------+
+Legend: FP = floating-point
+*/
+
+/// Floating-point registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum FPR {
+    F0 = 0,
+    F1 = 1,
+    F2 = 2,
+    F3 = 3,
+    F4 = 4,
+    F5 = 5,
+    F6 = 6,
+    F7 = 7,
+    F8 = 8,
+    F9 = 9,
+    F10 = 10,
+    F11 = 11,
+    F12 = 12,
+    F13 = 13,
+    F14 = 14,
+    F15 = 15,
+    F16 = 16,
+    F17 = 17,
+    F18 = 18,
+    F19 = 19,
+    F20 = 20,
+    F21 = 21,
+    F22 = 22,
+    F23 = 23,
+    F24 = 24,
+    F25 = 25,
+    F26 = 26,
+    F27 = 27,
+    F28 = 28,
+    F29 = 29,
+    F30 = 30,
+    F31 = 31,
+}
+
+impl From<FPR> for u8 {
+    fn from(val: FPR) -> Self {
+        val as u8
+    }
+}
+
+impl AbstractReg for FPR {
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<FPR, ()> {
+        match n {
+            0..=31 => Ok(*FPR::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, FPR> {
+        static FPRS: [FPR; 32] = [
+            FPR::F0,
+            FPR::F1,
+            FPR::F2,
+            FPR::F3,
+            FPR::F4,
+            FPR::F5,
+            FPR::F6,
+            FPR::F7,
+            FPR::F8,
+            FPR::F9,
+            FPR::F10,
+            FPR::F11,
+            FPR::F12,
+            FPR::F13,
+            FPR::F14,
+            FPR::F15,
+            FPR::F16,
+            FPR::F17,
+            FPR::F18,
+            FPR::F19,
+            FPR::F20,
+            FPR::F21,
+            FPR::F22,
+            FPR::F23,
+            FPR::F24,
+            FPR::F25,
+            FPR::F26,
+            FPR::F27,
+            FPR::F28,
+            FPR::F29,
+            FPR::F30,
+            FPR::F31,
+        ];
+        FPRS.iter()
+    }
+
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::RiscV;
+
+        match self {
+            FPR::F0 => RiscV::F0,
+            FPR::F1 => RiscV::F1,
+            FPR::F2 => RiscV::F2,
+            FPR::F3 => RiscV::F3,
+            FPR::F4 => RiscV::F4,
+            FPR::F5 => RiscV::F5,
+            FPR::F6 => RiscV::F6,
+            FPR::F7 => RiscV::F7,
+            FPR::F8 => RiscV::F8,
+            FPR::F9 => RiscV::F9,
+            FPR::F10 => RiscV::F10,
+            FPR::F11 => RiscV::F11,
+            FPR::F12 => RiscV::F12,
+            FPR::F13 => RiscV::F13,
+            FPR::F14 => RiscV::F14,
+            FPR::F15 => RiscV::F15,
+            FPR::F16 => RiscV::F16,
+            FPR::F17 => RiscV::F17,
+            FPR::F18 => RiscV::F18,
+            FPR::F19 => RiscV::F19,
+            FPR::F20 => RiscV::F20,
+            FPR::F21 => RiscV::F21,
+            FPR::F22 => RiscV::F22,
+            FPR::F23 => RiscV::F23,
+            FPR::F24 => RiscV::F24,
+            FPR::F25 => RiscV::F25,
+            FPR::F26 => RiscV::F26,
+            FPR::F27 => RiscV::F27,
+            FPR::F28 => RiscV::F28,
+            FPR::F29 => RiscV::F29,
+            FPR::F30 => RiscV::F30,
+            FPR::F31 => RiscV::F31,
+        }
+    }
+}
+
+/// A combined RISC-V register.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum RiscvRegister {
+    /// General-purpose register.
+    GPR(GPR),
+    /// Floating-point register.
+    FPR(FPR),
+}
+
+impl CombinedRegister for RiscvRegister {
+    fn from_gpr(x: u16) -> Self {
+        RiscvRegister::GPR(GPR::from_index(x as usize).unwrap())
+    }
+    fn from_simd(x: u16) -> Self {
+        RiscvRegister::FPR(FPR::from_index(x as usize).unwrap())
+    }
+}
+
+/// Allocator for function argument registers according to the RISC-V ABI.
+#[derive(Default)]
+pub struct ArgumentRegisterAllocator {
+    n_gprs: usize,
+    n_fprs: usize,
+}
+
+impl ArgumentRegisterAllocator {
+    /// Allocates a register for argument type `ty`. Returns `None` if no register is available.
+    #[allow(dead_code)]
+    pub fn next(&mut self, ty: Type) -> Result<Option<RiscvRegister>, CompileError> {
+        let ret = {
+            static GPR_SEQ: &[GPR] = &[
+                GPR::X10,
+                GPR::X11,
+                GPR::X12,
+                GPR::X13,
+                GPR::X14,
+                GPR::X15,
+                GPR::X16,
+                GPR::X17,
+            ];
+            static FPR_SEQ: &[FPR] = &[
+                FPR::F10,
+                FPR::F11,
+                FPR::F12,
+                FPR::F13,
+                FPR::F14,
+                FPR::F15,
+                FPR::F16,
+                FPR::F17,
+            ];
+            match ty {
+                Type::I32 | Type::I64 => {
+                    if self.n_gprs < GPR_SEQ.len() {
+                        let gpr = GPR_SEQ[self.n_gprs];
+                        self.n_gprs += 1;
+                        Some(RiscvRegister::GPR(gpr))
+                    } else {
+                        None
+                    }
+                }
+                Type::F32 | Type::F64 => {
+                    if self.n_fprs < FPR_SEQ.len() {
+                        let neon = FPR_SEQ[self.n_fprs];
+                        self.n_fprs += 1;
+                        Some(RiscvRegister::FPR(neon))
+                    } else {
+                        None
+                    }
+                }
+                _ => {
+                    return Err(CompileError::Codegen(format!(
+                        "No register available for type {ty}"
+                    )));
+                }
+            }
+        };
+
+        Ok(ret)
+    }
+}
diff --git a/lib/compiler-singlepass/src/unwind.rs b/lib/compiler-singlepass/src/unwind.rs
index ffda4500a9..b6ec3a3ecd 100644
--- a/lib/compiler-singlepass/src/unwind.rs
+++ b/lib/compiler-singlepass/src/unwind.rs
@@ -4,14 +4,46 @@ 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;
+
+use crate::location;
+
+#[derive(Clone, Debug, Copy)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum UnwindRegister<R: location::Reg, S: location::Reg> {
+    GPR(R),
+    FPR(S),
+}
+
+#[cfg(feature = "unwind")]
+impl<R: location::Reg, S: location::Reg> UnwindRegister<R, S> {
+    pub(crate) fn dwarf_index(&self) -> gimli::Register {
+        match self {
+            Self::GPR(reg) => reg.to_dwarf(),
+            Self::FPR(reg) => reg.to_dwarf(),
+        }
+    }
+}
 
 #[derive(Clone, Debug)]
-pub enum UnwindOps {
-    PushFP { up_to_sp: u32 },
-    Push2Regs { reg1: u16, reg2: u16, up_to_sp: u32 },
+#[cfg_attr(not(feature = "unwind"), allow(dead_code))]
+pub enum UnwindOps<R: location::Reg, S: location::Reg> {
+    PushFP {
+        up_to_sp: u32,
+    },
+    SubtractFP {
+        up_to_sp: u32,
+    },
+    Push2Regs {
+        reg1: UnwindRegister<R, S>,
+        reg2: UnwindRegister<R, S>,
+        up_to_sp: u32,
+    },
     DefineNewFrame,
-    SaveRegister { reg: u16, bp_neg_offset: i32 },
+    SaveRegister {
+        reg: UnwindRegister<R, S>,
+        bp_neg_offset: i32,
+    },
 }
 
 #[cfg(not(feature = "unwind"))]
@@ -76,6 +108,22 @@ pub fn create_systemv_cie(arch: Architecture) -> Option<gimli::write::CommonInfo
             entry.add_instruction(CallFrameInstruction::Cfa(AArch64::SP, 0));
             Some(entry)
         }
+        Architecture::Riscv64(_) => {
+            use gimli::RiscV;
+
+            let mut entry = CommonInformationEntry::new(
+                Encoding {
+                    address_size: 8,
+                    format: Format::Dwarf32,
+                    version: 1,
+                },
+                1,
+                -8,
+                RiscV::RA,
+            );
+            entry.add_instruction(CallFrameInstruction::Cfa(RiscV::SP, 0));
+            Some(entry)
+        }
         _ => None,
     }
 }
diff --git a/lib/compiler-singlepass/src/unwind_winx64.rs b/lib/compiler-singlepass/src/unwind_winx64.rs
index 389cba3c92..2dc0123fc1 100644
--- a/lib/compiler-singlepass/src/unwind_winx64.rs
+++ b/lib/compiler-singlepass/src/unwind_winx64.rs
@@ -1,6 +1,10 @@
 //! Windows x64 ABI unwind information.
 
-use crate::unwind::UnwindOps;
+use crate::{
+    location::Reg,
+    unwind::{UnwindOps, UnwindRegister},
+    x64_decl::{GPR, XMM},
+};
 
 /// Maximum (inclusive) size of a "small" stack allocation
 const SMALL_ALLOC_MAX_SIZE: u32 = 128;
@@ -106,7 +110,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 +159,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
@@ -240,7 +244,9 @@ impl UnwindInfo {
 
 const UNWIND_RBP_REG: u8 = 5;
 
-pub(crate) fn create_unwind_info_from_insts(insts: &[(usize, UnwindOps)]) -> Option<UnwindInfo> {
+pub(crate) fn create_unwind_info_from_insts(
+    insts: &[(usize, UnwindOps<GPR, XMM>)],
+) -> Option<UnwindInfo> {
     let mut unwind_codes = vec![];
     let mut frame_register_offset = 0;
     let mut max_unwind_offset = 0;
@@ -258,30 +264,23 @@ pub(crate) fn create_unwind_info_from_insts(insts: &[(usize, UnwindOps)]) -> Opt
                 unwind_codes.push(UnwindCode::SetFPReg { instruction_offset });
             }
             UnwindOps::SaveRegister { reg, bp_neg_offset } => match reg {
-                0..=15 => {
-                    // GPR reg
-                    static FROM_DWARF: [u8; 16] =
-                        [0, 2, 1, 3, 6, 7, 5, 4, 8, 9, 10, 11, 12, 13, 14, 15];
-                    unwind_codes.push(UnwindCode::SaveReg {
-                        instruction_offset,
-                        reg: FROM_DWARF[reg as usize],
-                        stack_offset: bp_neg_offset as u32,
-                    });
-                }
-                17..=32 => {
-                    unwind_codes.push(UnwindCode::SaveXmm {
-                        instruction_offset,
-                        reg: reg as u8 - 17,
-                        stack_offset: bp_neg_offset as u32,
-                    });
-                }
-                _ => {
-                    unreachable!("unknown register index {}", reg);
-                }
+                UnwindRegister::GPR(reg) => unwind_codes.push(UnwindCode::SaveReg {
+                    instruction_offset,
+                    // NOTE: We declare the register order in the same way as expected by the x64 exception handling ABI.
+                    reg: reg.into_index() as u8,
+                    stack_offset: bp_neg_offset as u32,
+                }),
+                UnwindRegister::FPR(reg) => unwind_codes.push(UnwindCode::SaveXmm {
+                    instruction_offset,
+                    // NOTE: We declare the register order in the same way as expected by the x64 exception handling ABI.
+                    reg: reg.into_index() as u8,
+                    stack_offset: bp_neg_offset as u32,
+                }),
             },
             UnwindOps::Push2Regs { .. } => {
                 unreachable!("no aarch64 on x64");
             }
+            UnwindOps::SubtractFP { .. } => unreachable!(),
         }
         max_unwind_offset = instruction_offset;
     }
diff --git a/lib/compiler-singlepass/src/x64_decl.rs b/lib/compiler-singlepass/src/x64_decl.rs
index 6178a17015..4c0ff98596 100644
--- a/lib/compiler-singlepass/src/x64_decl.rs
+++ b/lib/compiler-singlepass/src/x64_decl.rs
@@ -1,12 +1,10 @@
 //! X64 structures.
 
 #![allow(clippy::upper_case_acronyms)]
-use crate::common_decl::{MachineState, MachineValue, RegisterIndex};
 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::{CompileError, Type, target::CallingConvention};
 
 /// General-purpose registers.
 #[repr(u8)]
@@ -30,6 +28,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,17 +57,13 @@ pub enum XMM {
     XMM15 = 15,
 }
 
-impl AbstractReg for GPR {
-    fn is_callee_save(self) -> bool {
-        const IS_CALLEE_SAVE: [bool; 16] = [
-            false, false, false, true, true, true, false, false, false, false, false, false, true,
-            true, true, true,
-        ];
-        IS_CALLEE_SAVE[self as usize]
-    }
-    fn is_reserved(self) -> bool {
-        self == GPR::RSP || self == GPR::RBP || self == GPR::R10 || self == GPR::R15
+impl From<XMM> for u8 {
+    fn from(val: XMM) -> Self {
+        val as u8
     }
+}
+
+impl AbstractReg for GPR {
     fn into_index(self) -> usize {
         self as usize
     }
@@ -94,39 +94,32 @@ impl AbstractReg for GPR {
         ];
         GPRS.iter()
     }
-    fn to_dwarf(self) -> u16 {
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::X86_64;
+
         match self {
-            GPR::RAX => 0,
-            GPR::RDX => 1,
-            GPR::RCX => 2,
-            GPR::RBX => 3,
-            GPR::RSI => 4,
-            GPR::RDI => 5,
-            GPR::RBP => 6,
-            GPR::RSP => 7,
-            GPR::R8 => 8,
-            GPR::R9 => 9,
-            GPR::R10 => 10,
-            GPR::R11 => 11,
-            GPR::R12 => 12,
-            GPR::R13 => 13,
-            GPR::R14 => 14,
-            GPR::R15 => 15,
+            GPR::RAX => X86_64::RAX,
+            GPR::RCX => X86_64::RCX,
+            GPR::RDX => X86_64::RDX,
+            GPR::RBX => X86_64::RBX,
+            GPR::RSP => X86_64::RSP,
+            GPR::RBP => X86_64::RBP,
+            GPR::RSI => X86_64::RSI,
+            GPR::RDI => X86_64::RDI,
+            GPR::R8 => X86_64::R8,
+            GPR::R9 => X86_64::R9,
+            GPR::R10 => X86_64::R10,
+            GPR::R11 => X86_64::R11,
+            GPR::R12 => X86_64::R12,
+            GPR::R13 => X86_64::R13,
+            GPR::R14 => X86_64::R14,
+            GPR::R15 => X86_64::R15,
         }
     }
 }
 
 impl AbstractReg for XMM {
-    fn is_callee_save(self) -> bool {
-        const IS_CALLEE_SAVE: [bool; 16] = [
-            false, false, false, false, false, false, false, false, true, true, true, true, true,
-            true, true, true,
-        ];
-        IS_CALLEE_SAVE[self as usize]
-    }
-    fn is_reserved(self) -> bool {
-        false
-    }
     fn into_index(self) -> usize {
         self as usize
     }
@@ -157,8 +150,28 @@ impl AbstractReg for XMM {
         ];
         XMMS.iter()
     }
-    fn to_dwarf(self) -> u16 {
-        self.into_index() as u16 + 17
+    #[cfg(feature = "unwind")]
+    fn to_dwarf(self) -> gimli::Register {
+        use gimli::X86_64;
+
+        match self {
+            XMM::XMM0 => X86_64::XMM0,
+            XMM::XMM1 => X86_64::XMM1,
+            XMM::XMM2 => X86_64::XMM2,
+            XMM::XMM3 => X86_64::XMM3,
+            XMM::XMM4 => X86_64::XMM4,
+            XMM::XMM5 => X86_64::XMM5,
+            XMM::XMM6 => X86_64::XMM6,
+            XMM::XMM7 => X86_64::XMM7,
+            XMM::XMM8 => X86_64::XMM8,
+            XMM::XMM9 => X86_64::XMM9,
+            XMM::XMM10 => X86_64::XMM10,
+            XMM::XMM11 => X86_64::XMM11,
+            XMM::XMM12 => X86_64::XMM12,
+            XMM::XMM13 => X86_64::XMM13,
+            XMM::XMM14 => X86_64::XMM14,
+            XMM::XMM15 => X86_64::XMM15,
+        }
     }
 }
 
@@ -172,13 +185,6 @@ pub enum X64Register {
 }
 
 impl CombinedRegister for X64Register {
-    /// Returns the index of the register.
-    fn to_index(&self) -> RegisterIndex {
-        match *self {
-            X64Register::GPR(x) => RegisterIndex(x as usize),
-            X64Register::XMM(x) => RegisterIndex(x as usize + 16),
-        }
-    }
     /// Convert from a GPR register
     fn from_gpr(x: u16) -> Self {
         X64Register::GPR(GPR::from_index(x as usize).unwrap())
@@ -187,6 +193,7 @@ impl CombinedRegister for X64Register {
     fn from_simd(x: u16) -> Self {
         X64Register::XMM(XMM::from_index(x as usize).unwrap())
     }
+
     /* x86_64-abi-0.99.pdf
      * Register Name                    | Number | Abbreviation
      * General Purpose Register RAX     | 0      | %rax
@@ -220,32 +227,6 @@ impl CombinedRegister for X64Register {
      * x87 Control Word                 | 65     | %fcw
      * x87 Status Word                  | 66     | %fsw
      */
-    /// Converts a DWARF regnum to X64Register.
-    fn _from_dwarf_regnum(x: u16) -> Option<X64Register> {
-        static DWARF_REGS: [GPR; 16] = [
-            GPR::RAX,
-            GPR::RDX,
-            GPR::RCX,
-            GPR::RBX,
-            GPR::RSI,
-            GPR::RDI,
-            GPR::RBP,
-            GPR::RSP,
-            GPR::R8,
-            GPR::R9,
-            GPR::R10,
-            GPR::R11,
-            GPR::R12,
-            GPR::R13,
-            GPR::R14,
-            GPR::R15,
-        ];
-        Some(match x {
-            0..=15 => X64Register::GPR(DWARF_REGS[x as usize]),
-            17..=24 => X64Register::XMM(XMM::from_index(x as usize - 17).unwrap()),
-            _ => return None,
-        })
-    }
 }
 
 /// An allocator that allocates registers for function arguments according to the System V ABI.
@@ -257,8 +238,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 +267,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,23 +306,15 @@ impl ArgumentRegisterAllocator {
                             None
                         }
                     }
-                    _ => todo!(
-                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
-                        ty
-                    ),
+                    _ => {
+                        return Err(CompileError::Codegen(format!(
+                            "No register available for {calling_convention:?} and type {ty}"
+                        )));
+                    }
                 }
             }
-        }
-    }
-}
+        };
 
-/// Create a new `MachineState` with default values.
-pub fn new_machine_state() -> MachineState {
-    MachineState {
-        stack_values: vec![],
-        register_values: vec![MachineValue::Undefined; 16 + 8],
-        prev_frame: BTreeMap::new(),
-        wasm_stack: vec![],
-        wasm_inst_offset: std::usize::MAX,
+        Ok(ret)
     }
 }
diff --git a/lib/compiler/Cargo.toml b/lib/compiler/Cargo.toml
index abed0d3132..87d1335ed7 100644
--- a/lib/compiler/Cargo.toml
+++ b/lib/compiler/Cargo.toml
@@ -13,38 +13,50 @@ 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 }
-wasmparser = { workspace = true, optional = true, default-features = false }
+wasmer-types = { path = "../types", version = "=7.0.0", default-features = false }
+wasmparser = { workspace = true, default-features = false, optional = true }
 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"
-xxhash-rust = { version = "0.8.10", features = ["xxh64"] }
+hashbrown = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+thiserror.workspace = true
+serde_bytes = { workspace = true, optional = true }
+smallvec.workspace = true
+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"
-leb128 = "0.2"
-enum-iterator = "0.7.0"
+cfg-if.workspace = true
+leb128.workspace = true
+enum-iterator.workspace = true
 
-bytes = "1.0"
-self_cell = "1.0"
-rkyv = { workspace = true }
-shared-buffer = { workspace = true }
+bytes.workspace = true
+self_cell.workspace = true
+rkyv.workspace = true
+shared-buffer.workspace = true
 libc.workspace = true
+target-lexicon.workspace = true
+object = { workspace = true, features = ["write"] }
+itertools.workspace = true
+tempfile.workspace = true
+rangemap.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
-region = { version = "3.0" }
+wasmer-vm = { path = "../vm", version = "=7.0.0" }
+region.workspace = true
+which.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_System_Diagnostics_Debug"] }
+windows-sys = { workspace = true, features = [
+	"Win32_System_Diagnostics_Debug",
+] }
+
+[target.'cfg(all(target_os = "macos", target_arch = "aarch64"))'.dependencies]
+macho-unwind-info.workspace = true
 
 [features]
 default = ["std"]
@@ -56,19 +68,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..749af75ef3 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;
+
+use crate::{
+    ArtifactCreate, Features,
+    serialize::{
+        ArchivedSerializableCompilation, ArchivedSerializableModule, MetadataHeader,
+        SerializableModule,
+    },
+    types::{
+        function::{CompiledFunctionFrameInfo, FunctionBody, GOT, UnwindInfo},
+        module::CompileModuleInfo,
+        relocation::Relocation,
+        section::{CustomSection, SectionIndex},
+    },
+};
 #[cfg(feature = "compiler")]
-use crate::EngineInner;
-use crate::Features;
+use crate::{
+    EngineInner, ModuleEnvironment, ModuleMiddlewareChain, serialize::SerializableCompilation,
+};
 #[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,
-};
 use wasmer_types::{
-    CompiledFunctionFrameInfo, FunctionBody, HashAlgorithm, SerializableCompilation,
-    SerializableModule,
+    CompilationProgressCallback, DeserializeError,
+    entity::{ArchivedPrimaryMap, PrimaryMap},
+    target::CpuFeature,
 };
-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,
 }
@@ -55,7 +63,7 @@ impl ArtifactBuild {
         target: &Target,
         memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
         table_styles: PrimaryMap<TableIndex, TableStyle>,
-        hash_algorithm: Option<HashAlgorithm>,
+        progress_callback: Option<&CompilationProgressCallback>,
     ) -> Result<Self, CompileError> {
         let environ = ModuleEnvironment::new();
         let features = inner_engine.features().clone();
@@ -70,15 +78,7 @@ impl ArtifactBuild {
         middlewares
             .apply_on_module_info(&mut module)
             .map_err(|err| CompileError::MiddlewareError(err.to_string()))?;
-
-        if let Some(hash_algorithm) = hash_algorithm {
-            let hash = match hash_algorithm {
-                HashAlgorithm::Sha256 => ModuleHash::sha256(data),
-                HashAlgorithm::XXHash => ModuleHash::xxhash(data),
-            };
-
-            module.hash = Some(hash);
-        }
+        module.hash = Some(ModuleHash::new(data));
 
         let compile_info = CompileModuleInfo {
             module: Arc::new(module),
@@ -96,6 +96,7 @@ impl ArtifactBuild {
             // `module_translation_state`.
             translation.module_translation_state.as_ref().unwrap(),
             translation.function_body_inputs,
+            progress_callback,
         )?;
 
         let data_initializers = translation
@@ -134,9 +135,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 +194,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 +219,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 +277,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 +294,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 +312,7 @@ pub struct ArtifactBuildFromArchive {
 }
 
 impl ArtifactBuildFromArchive {
+    #[allow(unused)]
     pub(crate) fn try_new(
         buffer: OwnedBuffer,
         module_builder: impl FnOnce(
@@ -307,10 +323,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 +399,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 +410,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 +439,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 +455,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 +493,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..d45d2db6bb 100644
--- a/lib/compiler/src/artifact_builders/trampoline.rs
+++ b/lib/compiler/src/artifact_builders/trampoline.rs
@@ -3,10 +3,14 @@
 //! This is needed because the target of libcall relocations are not reachable
 //! through normal branch instructions.
 
-use enum_iterator::IntoEnumIterator;
-use wasmer_types::{
-    Architecture, CustomSection, CustomSectionProtection, LibCall, Relocation, RelocationKind,
-    RelocationTarget, SectionBody, Target,
+#![cfg_attr(not(feature = "compiler"), allow(dead_code))]
+
+use wasmer_types::LibCall;
+use wasmer_types::target::{Architecture, Target};
+
+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 +40,23 @@ const RISCV64_TRAMPOLINE: [u8; 24] = [
     0, 0, 0, 0,
 ];
 
+// AUIPC t1,0     17 03 00 00
+// LW t1, 12(t1)  03 a3 c2 00
+// JR t1          67 00 03 00
+// JMPADDR        00 00 00 00
+const RISCV32_TRAMPOLINE: [u8; 16] = [
+    0x17, 0x03, 0x00, 0x00, 0x03, 0xa3, 0xc2, 0x00, 0x67, 0x00, 0x03, 0x00, 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 +91,25 @@ fn make_trampoline(
                 addend: 0,
             });
         }
-        arch => panic!("Unsupported architecture: {}", arch),
+        Architecture::Riscv32(_) => {
+            code.extend(RISCV32_TRAMPOLINE);
+            relocations.push(Relocation {
+                kind: RelocationKind::Abs4,
+                reloc_target: RelocationTarget::LibCall(libcall),
+                offset: code.len() as u32 - 4,
+                addend: 0,
+            });
+        }
+        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 +119,9 @@ 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::Riscv32(_) => RISCV32_TRAMPOLINE.len(),
+        Architecture::LoongArch64 => LOONGARCH64_TRAMPOLINE.len(),
+        arch => panic!("Unsupported architecture: {arch}"),
     }
 }
 
@@ -88,11 +129,12 @@ pub fn libcall_trampoline_len(target: &Target) -> usize {
 pub fn make_libcall_trampolines(target: &Target) -> CustomSection {
     let mut code = vec![];
     let mut relocations = vec![];
-    for libcall in LibCall::into_enum_iter() {
+    for libcall in enum_iterator::all::<LibCall>() {
         make_trampoline(target, libcall, &mut code, &mut relocations);
     }
     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..332c8f6728 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::{
+    FunctionBodyData, ModuleTranslationState,
+    lib::std::{boxed::Box, sync::Arc},
+    translator::ModuleMiddleware,
+    types::function::Compilation,
+};
 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::{
+    CompilationProgressCallback, Features, LocalFunctionIndex,
+    entity::PrimaryMap,
+    error::CompileError,
+    target::{CpuFeature, Target, UserCompilerOptimizations},
+};
+#[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::CM_VALUES, false);
+        wasm_features.set(WasmFeatures::CM_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(())
     }
 
@@ -120,6 +154,7 @@ pub trait Compiler: Send {
         module_translation: &ModuleTranslationState,
         // The list of function bodies
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        progress_callback: Option<&CompilationProgressCallback>,
     ) -> Result<Compilation, CompileError>;
 
     /// Compiles a module into a native object file.
@@ -146,4 +181,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/constants.rs b/lib/compiler/src/constants.rs
new file mode 100644
index 0000000000..0c661edca4
--- /dev/null
+++ b/lib/compiler/src/constants.rs
@@ -0,0 +1,43 @@
+// Constants for the bounds of truncation operations. These are the least or
+// greatest exact floats in either f32 or f64 representation
+// greater-than-or-equal-to (for least) or less-than-or-equal-to (for greatest)
+// the i32 or i64 or u32 or u64 min (for least) or max (for greatest), when
+// rounding towards zero.
+
+/// Least Exact Float (32 bits) greater-than-or-equal-to i32::MIN when rounding towards zero.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub 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.
+pub const LEF32_GEQ_U64_MIN: u64 = u64::MIN;
+/// Greatest Exact Float (32 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
+pub 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.
+pub const LEF64_GEQ_U64_MIN: u64 = u64::MIN;
+/// Greatest Exact Float (64 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
+pub const GEF64_LEQ_U64_MAX: u64 = 18446744073709549568; // bits as f64: 0x43ef_ffff_ffff_ffff
+
+/// Canonical NaN value for f32 type
+pub const CANONICAL_NAN_F32: u32 = 0x7fc00000;
+/// Canonical NaN value for f64 type
+pub const CANONICAL_NAN_F64: u64 = 0x7ff8000000000000;
diff --git a/lib/compiler/src/engine/artifact.rs b/lib/compiler/src/engine/artifact.rs
index 0864abf46c..d9d24a7f3e 100644
--- a/lib/compiler/src/engine/artifact.rs
+++ b/lib/compiler/src/engine/artifact.rs
@@ -1,49 +1,53 @@
 //! 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::{
+    Arc,
+    atomic::{AtomicUsize, Ordering::SeqCst},
+};
+
+#[cfg(feature = "compiler")]
 use crate::ModuleEnvironment;
 use crate::{
-    register_frame_info, resolve_imports, FunctionExtent, GlobalFrameInfoRegistration,
-    InstantiationError, Tunables,
+    ArtifactBuild, ArtifactBuildFromArchive, ArtifactCreate, Engine, EngineInner, Features,
+    FrameInfosVariant, 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},
 };
 #[cfg(feature = "static-artifact-create")]
-use crate::{Compiler, FunctionBodyData, ModuleTranslationState};
-use crate::{Engine, EngineInner};
+use crate::{Compiler, FunctionBodyData, ModuleTranslationState, types::module::CompileModuleInfo};
+#[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
+use crate::{serialize::SerializableCompilation, types::symbols::ModuleMetadata};
+
 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::{
+    Object, ObjectMetadataBuilder, emit_compilation, emit_data, get_object_for_target,
+};
+
 use wasmer_types::{
-    CompileError, CpuFeature, DataInitializer, DeserializeError, FunctionIndex, HashAlgorithm,
-    LocalFunctionIndex, MemoryIndex, ModuleInfo, OwnedDataInitializer, SignatureIndex, TableIndex,
-    Target,
+    ArchivedDataInitializerLocation, ArchivedOwnedDataInitializer, CompilationProgressCallback,
+    CompileError, DataInitializer, DataInitializerLike, DataInitializerLocation,
+    DataInitializerLocationLike, DeserializeError, FunctionIndex, LocalFunctionIndex, MemoryIndex,
+    ModuleInfo, OwnedDataInitializer, SerializeError, SignatureIndex, TableIndex,
+    entity::{BoxedSlice, PrimaryMap},
+    target::{CpuFeature, Target},
+};
+
+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 +59,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 +68,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 +98,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 +110,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),
@@ -114,7 +124,7 @@ impl Artifact {
         engine: &Engine,
         data: &[u8],
         tunables: &dyn Tunables,
-        hash_algorithm: Option<HashAlgorithm>,
+        progress_callback: Option<CompilationProgressCallback>,
     ) -> Result<Self, CompileError> {
         let mut inner_engine = engine.inner_mut();
         let environ = ModuleEnvironment::new();
@@ -137,7 +147,7 @@ impl Artifact {
             engine.target(),
             memory_styles,
             table_styles,
-            hash_algorithm,
+            progress_callback.as_ref(),
         )?;
 
         Self::from_parts(
@@ -196,37 +206,39 @@ impl Artifact {
         engine: &Engine,
         bytes: OwnedBuffer,
     ) -> Result<Self, DeserializeError> {
-        if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
-            let static_artifact = Self::deserialize_object(engine, bytes);
-            match static_artifact {
-                Ok(v) => {
-                    return Ok(v);
-                }
-                Err(_) => {
-                    return Err(DeserializeError::Incompatible(
-                        "The provided bytes are not wasmer-universal".to_string(),
-                    ));
+        unsafe {
+            if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
+                let static_artifact = Self::deserialize_object(engine, bytes);
+                match static_artifact {
+                    Ok(v) => {
+                        return Ok(v);
+                    }
+                    Err(e) => {
+                        return Err(DeserializeError::Incompatible(format!(
+                            "The provided bytes are not wasmer-universal: {e}"
+                        )));
+                    }
                 }
             }
-        }
 
-        let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
-            let bytes =
-                Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
+            let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
+                let bytes =
+                    Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
 
-            let metadata_len = MetadataHeader::parse(bytes)?;
-            let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
-            let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+                let metadata_len = MetadataHeader::parse(bytes)?;
+                let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+                let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
 
-            SerializableModule::archive_from_slice_checked(metadata_slice)
-        })?;
+                SerializableModule::archive_from_slice_checked(metadata_slice)
+            })?;
 
-        let mut inner_engine = engine.inner_mut();
-        Self::from_parts(
-            &mut inner_engine,
-            ArtifactBuildVariant::Archived(artifact),
-            engine.target(),
-        )
+            let mut inner_engine = engine.inner_mut();
+            Self::from_parts(
+                &mut inner_engine,
+                ArtifactBuildVariant::Archived(artifact),
+                engine.target(),
+            )
+        }
     }
 
     /// Deserialize a serialized artifact.
@@ -241,37 +253,39 @@ impl Artifact {
         engine: &Engine,
         bytes: OwnedBuffer,
     ) -> Result<Self, DeserializeError> {
-        if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
-            let static_artifact = Self::deserialize_object(engine, bytes);
-            match static_artifact {
-                Ok(v) => {
-                    return Ok(v);
-                }
-                Err(_) => {
-                    return Err(DeserializeError::Incompatible(
-                        "The provided bytes are not wasmer-universal".to_string(),
-                    ));
+        unsafe {
+            if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
+                let static_artifact = Self::deserialize_object(engine, bytes);
+                match static_artifact {
+                    Ok(v) => {
+                        return Ok(v);
+                    }
+                    Err(e) => {
+                        return Err(DeserializeError::Incompatible(format!(
+                            "The provided bytes are not wasmer-universal: {e}"
+                        )));
+                    }
                 }
             }
-        }
 
-        let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
-            let bytes =
-                Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
+            let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
+                let bytes =
+                    Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
 
-            let metadata_len = MetadataHeader::parse(bytes)?;
-            let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
-            let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+                let metadata_len = MetadataHeader::parse(bytes)?;
+                let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+                let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
 
-            SerializableModule::archive_from_slice(metadata_slice)
-        })?;
+                SerializableModule::archive_from_slice(metadata_slice)
+            })?;
 
-        let mut inner_engine = engine.inner_mut();
-        Self::from_parts(
-            &mut inner_engine,
-            ArtifactBuildVariant::Archived(artifact),
-            engine.target(),
-        )
+            let mut inner_engine = engine.inner_mut();
+            Self::from_parts(
+                &mut inner_engine,
+                ArtifactBuildVariant::Archived(artifact),
+                engine.target(),
+            )
+        }
     }
 
     /// Construct a `ArtifactBuild` from component parts.
@@ -319,10 +333,49 @@ impl Artifact {
             )?,
         };
 
+        let get_got_address: Box<dyn Fn(RelocationTarget) -> Option<usize>> = match &artifact {
+            ArtifactBuildVariant::Plain(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(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,
                 &finished_functions,
+                &finished_dynamic_function_trampolines,
                 p.get_function_relocations()
                     .iter()
                     .map(|(k, v)| (k, v.iter())),
@@ -332,10 +385,12 @@ 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,
                 &finished_functions,
+                &finished_dynamic_function_trampolines,
                 a.get_function_relocations()
                     .iter()
                     .map(|(k, v)| (k, v.iter())),
@@ -345,6 +400,7 @@ impl Artifact {
                     .map(|(k, v)| (k, v.iter())),
                 a.get_libcall_trampolines(),
                 a.get_libcall_trampoline_len(),
+                &get_got_address,
             ),
         };
 
@@ -358,33 +414,62 @@ impl Artifact {
                 .collect::<PrimaryMap<_, _>>()
         };
 
-        let debug_ref = match &artifact {
-            ArtifactBuildVariant::Plain(p) => p.get_debug_ref(),
-            ArtifactBuildVariant::Archived(a) => a.get_debug_ref(),
+        #[allow(unused_variables)]
+        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)
+        #[allow(unused_variables)]
+        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,
         };
 
+        #[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
+        {
+            engine_inner.register_perfmap(&finished_functions, module_info)?;
+        }
+
         // Make all code compiled thus far executable.
         engine_inner.publish_compiled_code();
 
+        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+        if let Some(compact_unwind) = compact_unwind {
+            engine_inner.publish_compact_unwind(
+                compact_unwind,
+                get_got_address(RelocationTarget::LibCall(wasmer_vm::LibCall::EHPersonality)),
+            )?;
+        }
+        #[cfg(not(any(
+            target_arch = "wasm32",
+            all(target_os = "macos", target_arch = "aarch64")
+        )))]
         engine_inner.publish_eh_frame(eh_frame)?;
 
+        drop(get_got_address);
+
         let finished_function_lengths = finished_functions
             .values()
             .map(|extent| extent.length)
@@ -417,7 +502,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 +682,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 +695,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 +719,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 +773,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
@@ -775,71 +842,77 @@ impl Artifact {
         imports: &[VMExtern],
         context: &mut StoreObjects,
     ) -> Result<VMInstance, InstantiationError> {
-        // Validate the CPU features this module was compiled with against the
-        // host CPU features.
-        let host_cpu_features = CpuFeature::for_host();
-        if !host_cpu_features.is_superset(self.cpu_features()) {
-            return Err(InstantiationError::CpuFeature(format!(
-                "{:?}",
-                self.cpu_features().difference(host_cpu_features)
-            )));
-        }
+        unsafe {
+            // Validate the CPU features this module was compiled with against the
+            // host CPU features.
+            let host_cpu_features = CpuFeature::for_host();
+            if !host_cpu_features.is_superset(self.cpu_features()) {
+                return Err(InstantiationError::CpuFeature(format!(
+                    "{:?}",
+                    self.cpu_features().difference(host_cpu_features)
+                )));
+            }
 
-        self.preinstantiate()?;
+            self.preinstantiate()?;
 
-        let module = self.create_module_info();
-        let imports = resolve_imports(
-            &module,
-            imports,
-            context,
-            self.finished_dynamic_function_trampolines(),
-            self.memory_styles(),
-            self.table_styles(),
-        )
-        .map_err(InstantiationError::Link)?;
+            let module = self.create_module_info();
 
-        // Get pointers to where metadata about local memories should live in VM memory.
-        // Get pointers to where metadata about local tables should live in VM memory.
+            let tags = resolve_tags(&module, imports, context).map_err(InstantiationError::Link)?;
 
-        let (allocator, memory_definition_locations, table_definition_locations) =
-            InstanceAllocator::new(&module);
-        let finished_memories = tunables
-            .create_memories(
-                context,
+            let imports = resolve_imports(
                 &module,
+                imports,
+                context,
+                self.finished_dynamic_function_trampolines(),
                 self.memory_styles(),
-                &memory_definition_locations,
+                self.table_styles(),
             )
-            .map_err(InstantiationError::Link)?
-            .into_boxed_slice();
-        let finished_tables = tunables
-            .create_tables(
+            .map_err(InstantiationError::Link)?;
+
+            // Get pointers to where metadata about local memories should live in VM memory.
+            // Get pointers to where metadata about local tables should live in VM memory.
+
+            let (allocator, memory_definition_locations, table_definition_locations) =
+                InstanceAllocator::new(&module);
+            let finished_memories = tunables
+                .create_memories(
+                    context,
+                    &module,
+                    self.memory_styles(),
+                    &memory_definition_locations,
+                )
+                .map_err(InstantiationError::Link)?
+                .into_boxed_slice();
+            let finished_tables = tunables
+                .create_tables(
+                    context,
+                    &module,
+                    self.table_styles(),
+                    &table_definition_locations,
+                )
+                .map_err(InstantiationError::Link)?
+                .into_boxed_slice();
+            let finished_globals = tunables
+                .create_globals(context, &module)
+                .map_err(InstantiationError::Link)?
+                .into_boxed_slice();
+
+            let handle = VMInstance::new(
+                allocator,
+                module,
                 context,
-                &module,
-                self.table_styles(),
-                &table_definition_locations,
+                self.finished_functions().clone(),
+                self.finished_function_call_trampolines().clone(),
+                finished_memories,
+                finished_tables,
+                finished_globals,
+                tags,
+                imports,
+                self.signatures().clone(),
             )
-            .map_err(InstantiationError::Link)?
-            .into_boxed_slice();
-        let finished_globals = tunables
-            .create_globals(context, &module)
-            .map_err(InstantiationError::Link)?
-            .into_boxed_slice();
-
-        let handle = VMInstance::new(
-            allocator,
-            module,
-            context,
-            self.finished_functions().clone(),
-            self.finished_function_call_trampolines().clone(),
-            finished_memories,
-            finished_tables,
-            finished_globals,
-            imports,
-            self.signatures().clone(),
-        )
-        .map_err(InstantiationError::Start)?;
-        Ok(handle)
+            .map_err(InstantiationError::Start)?;
+            Ok(handle)
+        }
     }
 
     /// Finishes the instantiation of a just created `VMInstance`.
@@ -854,16 +927,18 @@ impl Artifact {
         trap_handler: Option<*const TrapHandlerFn<'static>>,
         handle: &mut VMInstance,
     ) -> Result<(), InstantiationError> {
-        let data_initializers = self
-            .data_initializers()
-            .map(|init| DataInitializer {
-                location: init.location().clone_to_plain(),
-                data: init.data(),
-            })
-            .collect::<Vec<_>>();
-        handle
-            .finish_instantiation(config, trap_handler, &data_initializers)
-            .map_err(InstantiationError::Start)
+        unsafe {
+            let data_initializers = self
+                .data_initializers()
+                .map(|init| DataInitializer {
+                    location: init.location().clone_to_plain(),
+                    data: init.data(),
+                })
+                .collect::<Vec<_>>();
+            handle
+                .finish_instantiation(config, trap_handler, &data_initializers)
+                .map_err(InstantiationError::Start)
+        }
     }
 
     #[allow(clippy::type_complexity)]
@@ -986,14 +1061,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 +1093,62 @@ 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,
+            None,
+        )?;
         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)?;
+        // MetadataHeader::parse requires that metadata must be aligned
+        // by 8 bytes.
+        let offset = emit_data(
+            &mut obj,
+            object_name.as_bytes(),
+            metadata_builder.placeholder_data(),
+            std::cmp::max(8, 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,116 +1189,119 @@ 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())?;
-        let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
-        let metadata: ModuleMetadata = ModuleMetadata::deserialize(metadata_slice)?;
-
-        const WORD_SIZE: usize = mem::size_of::<usize>();
-        let mut byte_buffer = [0u8; WORD_SIZE];
-
-        let mut cur_offset = MetadataHeader::LEN + metadata_len;
-
-        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
-        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
-        cur_offset += WORD_SIZE;
+        unsafe {
+            let bytes = bytes.as_slice();
+            let metadata_len = MetadataHeader::parse(bytes)?;
+            let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+            let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+            let metadata: ModuleMetadata = ModuleMetadata::deserialize(metadata_slice)?;
 
-        let num_finished_functions = usize::from_ne_bytes(byte_buffer);
-        let mut finished_functions: PrimaryMap<LocalFunctionIndex, FunctionBodyPtr> =
-            PrimaryMap::new();
+            const WORD_SIZE: usize = mem::size_of::<usize>();
+            let mut byte_buffer = [0u8; WORD_SIZE];
 
-        let engine_inner = engine.inner();
-        let signature_registry = engine_inner.signatures();
+            let mut cur_offset = MetadataHeader::LEN + metadata_len;
 
-        // read finished functions in order now...
-        for _i in 0..num_finished_functions {
             let byte_buffer_slice =
                 Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
             byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
-            let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
             cur_offset += WORD_SIZE;
 
-            // TODO: we can read back the length here if we serialize it. This will improve debug output.
-            finished_functions.push(fp);
-        }
+            let num_finished_functions = usize::from_ne_bytes(byte_buffer);
+            let mut finished_functions: PrimaryMap<LocalFunctionIndex, FunctionBodyPtr> =
+                PrimaryMap::new();
 
-        // We register all the signatures
-        let signatures = {
-            metadata
-                .compile_info
-                .module
-                .signatures
-                .values()
-                .map(|sig| signature_registry.register(sig))
-                .collect::<PrimaryMap<_, _>>()
-        };
+            let engine_inner = engine.inner();
+            let signature_registry = engine_inner.signatures();
+
+            // read finished functions in order now...
+            for _i in 0..num_finished_functions {
+                let byte_buffer_slice =
+                    Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+                byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+                let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
+                cur_offset += WORD_SIZE;
 
-        // read trampolines in order
-        let mut finished_function_call_trampolines = PrimaryMap::new();
+                // TODO: we can read back the length here if we serialize it. This will improve debug output.
+                finished_functions.push(fp);
+            }
+
+            // We register all the signatures
+            let signatures = {
+                metadata
+                    .compile_info
+                    .module
+                    .signatures
+                    .values()
+                    .map(|sig| signature_registry.register(sig))
+                    .collect::<PrimaryMap<_, _>>()
+            };
+
+            // read trampolines in order
+            let mut finished_function_call_trampolines = PrimaryMap::new();
 
-        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
-        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
-        cur_offset += WORD_SIZE;
-        let num_function_trampolines = usize::from_ne_bytes(byte_buffer);
-        for _ in 0..num_function_trampolines {
             let byte_buffer_slice =
                 Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
             byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
             cur_offset += WORD_SIZE;
-            let trampoline_ptr_bytes = usize::from_ne_bytes(byte_buffer);
-            let trampoline = mem::transmute::<usize, VMTrampoline>(trampoline_ptr_bytes);
-            finished_function_call_trampolines.push(trampoline);
-            // TODO: we can read back the length here if we serialize it. This will improve debug output.
-        }
+            let num_function_trampolines = usize::from_ne_bytes(byte_buffer);
+            for _ in 0..num_function_trampolines {
+                let byte_buffer_slice =
+                    Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+                byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+                cur_offset += WORD_SIZE;
+                let trampoline_ptr_bytes = usize::from_ne_bytes(byte_buffer);
+                let trampoline = mem::transmute::<usize, VMTrampoline>(trampoline_ptr_bytes);
+                finished_function_call_trampolines.push(trampoline);
+                // TODO: we can read back the length here if we serialize it. This will improve debug output.
+            }
 
-        // read dynamic function trampolines in order now...
-        let mut finished_dynamic_function_trampolines = PrimaryMap::new();
-        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
-        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
-        cur_offset += WORD_SIZE;
-        let num_dynamic_trampoline_functions = usize::from_ne_bytes(byte_buffer);
-        for _i in 0..num_dynamic_trampoline_functions {
+            // read dynamic function trampolines in order now...
+            let mut finished_dynamic_function_trampolines = PrimaryMap::new();
             let byte_buffer_slice =
                 Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
             byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
-            let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
             cur_offset += WORD_SIZE;
+            let num_dynamic_trampoline_functions = usize::from_ne_bytes(byte_buffer);
+            for _i in 0..num_dynamic_trampoline_functions {
+                let byte_buffer_slice =
+                    Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+                byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+                let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
+                cur_offset += WORD_SIZE;
 
-            // TODO: we can read back the length here if we serialize it. This will improve debug output.
+                // TODO: we can read back the length here if we serialize it. This will improve debug output.
 
-            finished_dynamic_function_trampolines.push(fp);
-        }
+                finished_dynamic_function_trampolines.push(fp);
+            }
 
-        let artifact = ArtifactBuild::from_serializable(SerializableModule {
-            compilation: SerializableCompilation::default(),
-            compile_info: metadata.compile_info,
-            data_initializers: metadata.data_initializers,
-            cpu_features: metadata.cpu_features,
-        });
+            let artifact = ArtifactBuild::from_serializable(SerializableModule {
+                compilation: SerializableCompilation::default(),
+                compile_info: metadata.compile_info,
+                data_initializers: metadata.data_initializers,
+                cpu_features: metadata.cpu_features,
+            });
 
-        let finished_function_lengths = finished_functions
-            .values()
-            .map(|_| 0)
-            .collect::<PrimaryMap<LocalFunctionIndex, usize>>()
-            .into_boxed_slice();
+            let finished_function_lengths = finished_functions
+                .values()
+                .map(|_| 0)
+                .collect::<PrimaryMap<LocalFunctionIndex, usize>>()
+                .into_boxed_slice();
 
-        Ok(Self {
-            id: Default::default(),
-            artifact: ArtifactBuildVariant::Plain(artifact),
-            allocated: Some(AllocatedArtifact {
-                frame_info_registered: false,
-                frame_info_registration: None,
-                finished_functions: finished_functions.into_boxed_slice(),
-                finished_function_call_trampolines: finished_function_call_trampolines
-                    .into_boxed_slice(),
-                finished_dynamic_function_trampolines: finished_dynamic_function_trampolines
-                    .into_boxed_slice(),
-                signatures: signatures.into_boxed_slice(),
-                finished_function_lengths,
-            }),
-        })
+            Ok(Self {
+                id: Default::default(),
+                artifact: ArtifactBuildVariant::Plain(artifact),
+                allocated: Some(AllocatedArtifact {
+                    frame_info_registered: false,
+                    frame_info_registration: None,
+                    finished_functions: finished_functions.into_boxed_slice(),
+                    finished_function_call_trampolines: finished_function_call_trampolines
+                        .into_boxed_slice(),
+                    finished_dynamic_function_trampolines: finished_dynamic_function_trampolines
+                        .into_boxed_slice(),
+                    signatures: signatures.into_boxed_slice(),
+                    finished_function_lengths,
+                }),
+            })
+        }
     }
 }
diff --git a/lib/compiler/src/engine/builder.rs b/lib/compiler/src/engine/builder.rs
index 5cb356526b..81c942bdbf 100644
--- a/lib/compiler/src/engine/builder.rs
+++ b/lib/compiler/src/engine/builder.rs
@@ -1,21 +1,22 @@
 use super::Engine;
+#[cfg(feature = "compiler")]
 use crate::CompilerConfig;
-use wasmer_types::{Features, HashAlgorithm, Target};
+use wasmer_types::{Features, target::Target};
 
 /// 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>,
     /// The features to compile the Wasm module with
     features: Option<Features>,
-    /// The hashing algorithm
-    hash_algorithm: Option<HashAlgorithm>,
 }
 
 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>>,
@@ -24,17 +25,16 @@ impl EngineBuilder {
             compiler_config: Some(compiler_config.into()),
             target: None,
             features: None,
-            hash_algorithm: None,
         }
     }
 
     /// Create a new headless Backend
     pub fn headless() -> Self {
         Self {
+            #[cfg(feature = "compiler")]
             compiler_config: None,
             target: None,
             features: None,
-            hash_algorithm: None,
         }
     }
 
@@ -50,12 +50,6 @@ impl EngineBuilder {
         self
     }
 
-    /// Set the hashing algorithm
-    pub fn set_hash_algorithm(mut self, hash_algorithm: Option<HashAlgorithm>) -> Self {
-        self.hash_algorithm = hash_algorithm;
-        self
-    }
-
     /// Build the `Engine` for this configuration
     #[cfg(feature = "compiler")]
     pub fn engine(self) -> Engine {
@@ -64,11 +58,7 @@ impl EngineBuilder {
             let features = self
                 .features
                 .unwrap_or_else(|| compiler_config.default_features_for_target(&target));
-            let mut engine = Engine::new(compiler_config, target, features);
-
-            engine.set_hash_algorithm(self.hash_algorithm);
-
-            engine
+            Engine::new(compiler_config, target, features)
         } else {
             Engine::headless()
         }
diff --git a/lib/compiler/src/engine/code_memory.rs b/lib/compiler/src/engine/code_memory.rs
index 99e413243e..19166c69a4 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::{
+    GlobalFrameInfoRegistration,
+    types::{
+        function::FunctionBodyLike,
+        section::CustomSectionLike,
+        unwind::{CompiledFunctionUnwindInfoLike, CompiledFunctionUnwindInfoReference},
+    },
 };
 use wasmer_vm::{Mmap, VMFunctionBody};
 
@@ -114,12 +117,12 @@ impl CodeMemory {
             bytes += len;
 
             let vmfunc = Self::copy_function(&mut self.unwind_registry, *func, func_buf);
-            assert_eq!(vmfunc.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+            assert!((vmfunc.as_ptr() as usize).is_multiple_of(ARCH_FUNCTION_ALIGNMENT));
             function_result.push(vmfunc);
         }
         for section in executable_sections {
             let section = section.bytes();
-            assert_eq!(buf.as_mut_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+            assert!((buf.as_mut_ptr() as usize).is_multiple_of(ARCH_FUNCTION_ALIGNMENT));
             let len = round_up(section.len(), ARCH_FUNCTION_ALIGNMENT);
             let (s, next_buf) = buf.split_at_mut(len);
             buf = next_buf;
@@ -138,7 +141,7 @@ impl CodeMemory {
 
             for section in data_sections {
                 let section = section.bytes();
-                assert_eq!(buf.as_mut_ptr() as usize % DATA_SECTION_ALIGNMENT, 0);
+                assert!((buf.as_mut_ptr() as usize).is_multiple_of(DATA_SECTION_ALIGNMENT));
                 let len = round_up(section.len(), DATA_SECTION_ALIGNMENT);
                 let (s, next_buf) = buf.split_at_mut(len);
                 buf = next_buf;
@@ -177,7 +180,7 @@ impl CodeMemory {
                 // Windows unwind information is required to be emitted into code memory
                 // This is because it must be a positive relative offset from the start of the memory
                 // Account for necessary unwind information alignment padding (32-bit alignment)
-                ((func.body().len() + 3) & !3) + info.len()
+                func.body().len().next_multiple_of(4) + info.len()
             }
             _ => func.body().len(),
         }
@@ -191,7 +194,7 @@ impl CodeMemory {
         func: &'module impl FunctionBodyLike<'module>,
         buf: &'memory mut [u8],
     ) -> &'memory mut [VMFunctionBody] {
-        assert_eq!(buf.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+        assert!((buf.as_ptr() as usize).is_multiple_of(ARCH_FUNCTION_ALIGNMENT));
 
         let func_len = func.body().len();
 
@@ -203,10 +206,10 @@ impl CodeMemory {
         if let Some(CompiledFunctionUnwindInfoReference::WindowsX64(info)) = unwind_info {
             // Windows unwind information is written following the function body
             // Keep unwind information 32-bit aligned (round up to the nearest 4 byte boundary)
-            let unwind_start = (func_len + 3) & !3;
+            let unwind_start = func_len.next_multiple_of(4);
             let unwind_size = info.len();
             let padding = unwind_start - func_len;
-            assert_eq!((func_len + padding) % 4, 0);
+            assert!((func_len + padding).is_multiple_of(4));
             let slice = remainder.split_at_mut(padding + unwind_size).0;
             slice[padding..].copy_from_slice(info);
         }
@@ -235,7 +238,7 @@ impl CodeMemory {
 
 fn round_up(size: usize, multiple: usize) -> usize {
     debug_assert!(multiple.is_power_of_two());
-    (size + (multiple - 1)) & !(multiple - 1)
+    size.next_multiple_of(multiple)
 }
 
 #[cfg(test)]
diff --git a/lib/compiler/src/engine/error.rs b/lib/compiler/src/engine/error.rs
index b5f9c0fb84..e090022813 100644
--- a/lib/compiler/src/engine/error.rs
+++ b/lib/compiler/src/engine/error.rs
@@ -18,7 +18,7 @@ pub enum LinkError {
     Import(String, String, ImportError),
 
     #[cfg(not(target_arch = "wasm32"))]
-    /// A trap ocurred during linking.
+    /// A trap occurred during linking.
     #[error("Trap occurred during linking: {0}")]
     Trap(#[source] Trap),
 
@@ -36,7 +36,7 @@ pub enum LinkError {
 /// start function.
 #[derive(Error, Debug)]
 pub enum InstantiationError {
-    /// A linking ocurred during instantiation.
+    /// A linking occurred during instantiation.
     #[error(transparent)]
     Link(LinkError),
 
diff --git a/lib/compiler/src/engine/inner.rs b/lib/compiler/src/engine/inner.rs
index 3957c8fe1d..cf2f3dfe00 100644
--- a/lib/compiler/src/engine/inner.rs
+++ b/lib/compiler/src/engine/inner.rs
@@ -1,33 +1,39 @@
 //! Universal compilation.
 
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::sync::{Arc, Mutex};
+
 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;
 #[cfg(feature = "compiler")]
 use crate::{Compiler, CompilerConfig};
-#[cfg(not(target_arch = "wasm32"))]
-use crate::{FunctionExtent, Tunables};
+
+#[cfg(feature = "compiler")]
+use wasmer_types::Features;
+use wasmer_types::{CompilationProgressCallback, CompileError, target::Target};
+
 #[cfg(not(target_arch = "wasm32"))]
 use shared_buffer::OwnedBuffer;
+#[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
+use std::io::Write;
 #[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;
+#[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
+use wasmer_types::ModuleInfo;
 #[cfg(not(target_arch = "wasm32"))]
 use wasmer_types::{
-    entity::PrimaryMap, DeserializeError, FunctionBodyLike, FunctionIndex, FunctionType,
-    LocalFunctionIndex, SignatureIndex,
+    DeserializeError, FunctionIndex, FunctionType, LocalFunctionIndex, SignatureIndex,
+    entity::PrimaryMap,
 };
-use wasmer_types::{CompileError, Features, ModuleInfo, Target};
+
 #[cfg(not(target_arch = "wasm32"))]
-use wasmer_types::{CustomSectionLike, CustomSectionProtection, SectionIndex};
+use crate::{
+    Artifact, BaseTunables, CodeMemory, FunctionExtent, GlobalFrameInfoRegistration, Tunables,
+    types::{
+        function::FunctionBodyLike,
+        section::{CustomSectionLike, CustomSectionProtection, SectionIndex},
+    },
+};
+
 #[cfg(not(target_arch = "wasm32"))]
 use wasmer_vm::{
     FunctionBodyPtr, SectionBodyPtr, SignatureRegistry, VMFunctionBody, VMSharedSignatureIndex,
@@ -44,7 +50,6 @@ pub struct Engine {
     #[cfg(not(target_arch = "wasm32"))]
     tunables: Arc<dyn Tunables + Send + Sync>,
     name: String,
-    hash_algorithm: Option<HashAlgorithm>,
 }
 
 impl Engine {
@@ -73,41 +78,30 @@ impl Engine {
             #[cfg(not(target_arch = "wasm32"))]
             tunables: Arc::new(tunables),
             name,
-            hash_algorithm: None,
         }
     }
 
-    #[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()
     }
 
-    /// Sets the hash algorithm
-    pub fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>) {
-        self.hash_algorithm = hash_algorithm;
-    }
-
-    /// Returns the hash algorithm
-    pub fn hash_algorithm(&self) -> Option<HashAlgorithm> {
-        self.hash_algorithm
-    }
-
     /// 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 {
+        #[cfg(feature = "compiler")]
+        {
+            let i = self.inner();
+            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`
@@ -143,7 +137,6 @@ impl Engine {
             #[cfg(not(target_arch = "wasm32"))]
             tunables: Arc::new(tunables),
             name: "engine-headless".to_string(),
-            hash_algorithm: None,
         }
     }
 
@@ -190,7 +183,22 @@ impl Engine {
             self,
             binary,
             self.tunables.as_ref(),
-            self.hash_algorithm,
+            None,
+        )?))
+    }
+
+    /// Compile a WebAssembly binary with a progress callback.
+    #[cfg(feature = "compiler")]
+    pub fn compile_with_progress(
+        &self,
+        binary: &[u8],
+        progress_callback: Option<CompilationProgressCallback>,
+    ) -> Result<Arc<Artifact>, CompileError> {
+        Ok(Arc::new(Artifact::new(
+            self,
+            binary,
+            self.tunables.as_ref(),
+            progress_callback,
         )?))
     }
 
@@ -209,7 +217,7 @@ impl Engine {
 
     #[cfg(not(target_arch = "wasm32"))]
     /// Deserializes a WebAssembly module which was previously serialized with
-    /// [`Module::serialize`].
+    /// [`wasmer::Module::serialize`].
     ///
     /// # Safety
     ///
@@ -218,11 +226,11 @@ impl Engine {
         &self,
         bytes: OwnedBuffer,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        Ok(Arc::new(Artifact::deserialize_unchecked(self, bytes)?))
+        unsafe { Ok(Arc::new(Artifact::deserialize_unchecked(self, bytes)?)) }
     }
 
     /// Deserializes a WebAssembly module which was previously serialized with
-    /// [`Module::serialize`].
+    /// [`wasmer::Module::serialize`].
     ///
     /// # Safety
     ///
@@ -232,7 +240,7 @@ impl Engine {
         &self,
         bytes: OwnedBuffer,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        Ok(Arc::new(Artifact::deserialize(self, bytes)?))
+        unsafe { Ok(Arc::new(Artifact::deserialize(self, bytes)?)) }
     }
 
     /// Deserializes a WebAssembly module from a path.
@@ -244,10 +252,13 @@ impl Engine {
         &self,
         file_ref: &Path,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        let file = std::fs::File::open(file_ref)?;
-        self.deserialize(
-            OwnedBuffer::from_file(&file).map_err(|e| DeserializeError::Generic(e.to_string()))?,
-        )
+        unsafe {
+            let file = std::fs::File::open(file_ref)?;
+            self.deserialize(
+                OwnedBuffer::from_file(&file)
+                    .map_err(|e| DeserializeError::Generic(e.to_string()))?,
+            )
+        }
     }
 
     /// Deserialize from a file path.
@@ -260,10 +271,13 @@ impl Engine {
         &self,
         file_ref: &Path,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        let file = std::fs::File::open(file_ref)?;
-        self.deserialize_unchecked(
-            OwnedBuffer::from_file(&file).map_err(|e| DeserializeError::Generic(e.to_string()))?,
-        )
+        unsafe {
+            let file = std::fs::File::open(file_ref)?;
+            self.deserialize_unchecked(
+                OwnedBuffer::from_file(&file)
+                    .map_err(|e| DeserializeError::Generic(e.to_string()))?,
+            )
+        }
     }
 
     /// A unique identifier for this object.
@@ -291,15 +305,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 +353,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 +401,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 +428,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 +442,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 +475,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 +485,6 @@ impl EngineInner {
                 )
             })
             .collect::<PrimaryMap<SectionIndex, _>>();
-
         Ok((
             allocated_functions_result,
             allocated_function_call_trampolines,
@@ -452,15 +500,33 @@ impl EngineInner {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
     /// Register DWARF-type exception handling information associated with the code.
     pub(crate) fn publish_eh_frame(&mut self, eh_frame: Option<&[u8]>) -> Result<(), CompileError> {
         self.code_memory
             .last_mut()
             .unwrap()
             .unwind_registry_mut()
-            .publish(eh_frame)
+            .publish_eh_frame(eh_frame)
+            .map_err(|e| {
+                CompileError::Resource(format!("Error while publishing the unwind code: {e}"))
+            })?;
+        Ok(())
+    }
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    /// Register macos-specific exception handling information associated with the code.
+    pub(crate) fn publish_compact_unwind(
+        &mut self,
+        compact_unwind: &[u8],
+        eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), CompileError> {
+        self.code_memory
+            .last_mut()
+            .unwrap()
+            .unwind_registry_mut()
+            .publish_compact_unwind(compact_unwind, eh_personality_addr_in_got)
             .map_err(|e| {
-                CompileError::Resource(format!("Error while publishing the unwind code: {}", e))
+                CompileError::Resource(format!("Error while publishing the unwind code: {e}"))
             })?;
         Ok(())
     }
@@ -479,6 +545,42 @@ impl EngineInner {
             .unwrap()
             .register_frame_info(frame_info);
     }
+
+    #[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
+    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..e25ffc7375 100644
--- a/lib/compiler/src/engine/link.rs
+++ b/lib/compiler/src/engine/link.rs
@@ -1,55 +1,110 @@
 //! 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::{
+    FunctionExtent, get_libcall_trampoline,
+    types::{
+        relocation::{RelocationKind, RelocationLike, RelocationTarget},
+        section::SectionIndex,
+    },
+};
+use std::{
+    collections::{HashMap, HashSet},
+    ptr::{read_unaligned, write_unaligned},
+};
 
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, ModuleInfo, entity::PrimaryMap};
+use wasmer_vm::{FunctionBodyPtr, SectionBodyPtr, libcalls::function_pointer};
+
+const LOW6_BITS_MASK: u8 = 0x3f;
+
+#[allow(clippy::too_many_arguments)]
 fn apply_relocation(
     body: usize,
     r: &impl RelocationLike,
     allocated_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
+    allocated_dynamic_function_trampolines: &PrimaryMap<FunctionIndex, FunctionBodyPtr>,
     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::DynamicTrampoline(index) => {
+                *allocated_dynamic_function_trampolines[index] 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::PCRel8
+                        | 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::Abs6Bits => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u8) & !LOW6_BITS_MASK;
+            write_unaligned(
+                reloc_address as *mut u8,
+                value | ((reloc_abs as u8) & LOW6_BITS_MASK),
+            );
+        },
+        RelocationKind::Abs => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u8, reloc_abs as u8);
+        },
+        RelocationKind::Abs2 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u16, reloc_abs as u16);
+        },
+        RelocationKind::Abs4 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u32, reloc_abs as u32);
+        },
         RelocationKind::Abs8 => unsafe {
-            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
-            write_unaligned(reloc_address as *mut u64, reloc_delta);
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u64, reloc_abs);
         },
-        RelocationKind::X86PCRel4 => unsafe {
+        RelocationKind::PCRel4 => unsafe {
             let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
             write_unaligned(reloc_address as *mut u32, reloc_delta as _);
         },
-        RelocationKind::X86PCRel8 => unsafe {
+        RelocationKind::PCRel8 => unsafe {
             let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
             write_unaligned(reloc_address as *mut u64, reloc_delta);
         },
@@ -122,18 +177,332 @@ 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);
+        },
+        RelocationKind::Add => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u8);
+            write_unaligned(
+                reloc_address as *mut u8,
+                value.wrapping_add(reloc_abs as u8),
+            );
+        },
+        RelocationKind::Add2 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u16);
+            write_unaligned(
+                reloc_address as *mut u16,
+                value.wrapping_add(reloc_abs as u16),
+            );
+        },
+        RelocationKind::Add4 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u32);
+            write_unaligned(
+                reloc_address as *mut u32,
+                value.wrapping_add(reloc_abs as u32),
+            );
+        },
+        RelocationKind::Add8 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u64);
+            write_unaligned(reloc_address as *mut u64, value.wrapping_add(reloc_abs));
+        },
+        RelocationKind::Sub6Bits => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u8);
+            let upper_2_bits = value & !LOW6_BITS_MASK;
+            write_unaligned(
+                reloc_address as *mut u8,
+                (value.wrapping_sub((reloc_abs as u8) & LOW6_BITS_MASK) & LOW6_BITS_MASK)
+                    | upper_2_bits,
+            );
+        },
+        RelocationKind::Sub => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u8);
+            write_unaligned(
+                reloc_address as *mut u8,
+                value.wrapping_sub(reloc_abs as u8),
+            );
+        },
+        RelocationKind::Sub2 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u16);
+            write_unaligned(
+                reloc_address as *mut u16,
+                value.wrapping_sub(reloc_abs as u16),
+            );
+        },
+        RelocationKind::Sub4 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u32);
+            write_unaligned(
+                reloc_address as *mut u32,
+                value.wrapping_sub(reloc_abs as u32),
+            );
+        },
+        RelocationKind::Sub8 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let value = read_unaligned(reloc_address as *mut u64);
+            write_unaligned(reloc_address as *mut u64, value.wrapping_sub(reloc_abs));
+        },
+        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>,
+    allocated_dynamic_function_trampolines: &PrimaryMap<FunctionIndex, FunctionBodyPtr>,
     function_relocations: impl Iterator<
         Item = (
             LocalFunctionIndex,
@@ -149,6 +518,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();
 
@@ -159,10 +529,12 @@ pub fn link_module<'a>(
                 body,
                 r,
                 allocated_functions,
+                allocated_dynamic_function_trampolines,
                 allocated_sections,
                 libcall_trampolines,
                 trampoline_len,
                 &mut riscv_pcrel_hi20s,
+                get_got_address,
             );
         }
     }
@@ -173,10 +545,12 @@ pub fn link_module<'a>(
                 body,
                 r,
                 allocated_functions,
+                allocated_dynamic_function_trampolines,
                 allocated_sections,
                 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..86b81bbfd7 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::{
     ExternType, FunctionIndex, ImportError, ImportIndex, MemoryIndex, ModuleInfo, TableIndex,
+    TagType,
+};
+use wasmer_types::{
+    TagIndex, TagKind,
+    entity::{BoxedSlice, EntityRef, PrimaryMap},
 };
 
 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..abee089e3c 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::ArtifactBuildFromArchive;
+use crate::types::address_map::{
+    ArchivedFunctionAddressMap, ArchivedInstructionAddressMap, FunctionAddressMap,
+    InstructionAddressMap,
+};
+use crate::types::function::{ArchivedCompiledFunctionFrameInfo, CompiledFunctionFrameInfo};
 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,
+    FrameInfo, LocalFunctionIndex, ModuleInfo, SourceLoc, TrapInformation,
+    entity::{BoxedSlice, EntityRef, PrimaryMap},
 };
 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.
@@ -72,7 +70,7 @@ impl ModuleInfoFrameInfo {
     fn function_debug_info(
         &self,
         local_index: LocalFunctionIndex,
-    ) -> CompiledFunctionFrameInfoVariant {
+    ) -> CompiledFunctionFrameInfoVariant<'_> {
         self.frame_infos.get(local_index).unwrap()
     }
 
@@ -204,7 +202,7 @@ pub enum FrameInfosVariant {
 
 impl FrameInfosVariant {
     /// Gets the frame info for a given local function index
-    pub fn get(&self, index: LocalFunctionIndex) -> Option<CompiledFunctionFrameInfoVariant> {
+    pub fn get(&self, index: LocalFunctionIndex) -> Option<CompiledFunctionFrameInfoVariant<'_>> {
         match self {
             Self::Owned(map) => map.get(index).map(CompiledFunctionFrameInfoVariant::Ref),
             Self::Archived(archive) => archive
@@ -238,13 +236,14 @@ impl CompiledFunctionFrameInfoVariant<'_> {
     }
 
     /// Gets the traps for the frame info
-    pub fn traps(&self) -> VecTrapInformationVariant {
+    pub fn traps(&self) -> VecTrapInformationVariant<'_> {
         match self {
             CompiledFunctionFrameInfoVariant::Ref(info) => {
                 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,
         }
     }
 }
@@ -275,7 +275,7 @@ pub enum FunctionAddressMapVariant<'a> {
 }
 
 impl FunctionAddressMapVariant<'_> {
-    pub fn instructions(&self) -> FunctionAddressMapInstructionVariant {
+    pub fn instructions(&self) -> FunctionAddressMapInstructionVariant<'_> {
         match self {
             FunctionAddressMapVariant::Ref(map) => {
                 FunctionAddressMapInstructionVariant::Owned(&map.instructions)
@@ -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/trap/mod.rs b/lib/compiler/src/engine/trap/mod.rs
index 9841597304..262ca5f338 100644
--- a/lib/compiler/src/engine/trap/mod.rs
+++ b/lib/compiler/src/engine/trap/mod.rs
@@ -1,7 +1,7 @@
 mod frame_info;
 mod stack;
 pub use frame_info::{
-    register as register_frame_info, CompiledFunctionFrameInfoVariant, FrameInfosVariant,
-    FunctionExtent, GlobalFrameInfoRegistration, FRAME_INFO,
+    CompiledFunctionFrameInfoVariant, FRAME_INFO, FrameInfosVariant, FunctionExtent,
+    GlobalFrameInfoRegistration, register as register_frame_info,
 };
-pub use stack::get_trace_and_trapcode;
+pub use stack::{get_trace_and_trapcode, wasm_trace_from_current_stack};
diff --git a/lib/compiler/src/engine/trap/stack.rs b/lib/compiler/src/engine/trap/stack.rs
index aa07f93a98..95b95d8f82 100644
--- a/lib/compiler/src/engine/trap/stack.rs
+++ b/lib/compiler/src/engine/trap/stack.rs
@@ -1,10 +1,21 @@
-use super::frame_info::{GlobalFrameInfo, FRAME_INFO};
+#[cfg(unix)]
+use crate::engine::unwind::EXIT_CALLED;
+#[cfg(unix)]
+use std::sync::atomic::Ordering;
+
+use super::frame_info::{FRAME_INFO, GlobalFrameInfo};
 use backtrace::Backtrace;
 use wasmer_types::{FrameInfo, TrapCode};
 use wasmer_vm::Trap;
 
 /// Given a `Trap`, this function returns the Wasm trace and the trap code.
 pub fn get_trace_and_trapcode(trap: &Trap) -> (Vec<FrameInfo>, Option<TrapCode>) {
+    #[cfg(unix)]
+    // If the exit is called, we can't access the back-trace information any longer (#5877)
+    if EXIT_CALLED.load(Ordering::SeqCst) {
+        return (Vec::new(), None);
+    }
+
     let info = FRAME_INFO.read().unwrap();
     match &trap {
         // A user error
@@ -30,9 +41,23 @@ pub fn get_trace_and_trapcode(trap: &Trap) -> (Vec<FrameInfo>, Option<TrapCode>)
             trap_code,
             backtrace,
         } => (wasm_trace(&info, None, backtrace), Some(*trap_code)),
+        // An uncaught exception
+        Trap::UncaughtException { backtrace, .. } => (
+            wasm_trace(&info, None, backtrace),
+            Some(TrapCode::UncaughtException),
+        ),
     }
 }
 
+/// Captures the current Wasm stack trace. Only useful when
+/// there are active Wasm frames on the stack, such as in
+/// libcalls or imported functions.
+pub fn wasm_trace_from_current_stack() -> Vec<FrameInfo> {
+    let info = FRAME_INFO.read().unwrap();
+    let backtrace = Backtrace::new_unresolved();
+    wasm_trace(&info, None, &backtrace)
+}
+
 fn wasm_trace(
     info: &GlobalFrameInfo,
     trap_pc: Option<usize>,
diff --git a/lib/compiler/src/engine/tunables.rs b/lib/compiler/src/engine/tunables.rs
index 266c3bdaf8..a37dd3eed3 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,
+    FunctionType, GlobalType, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
+    MemoryType, ModuleInfo, Pages, TableIndex, TableType, TagKind,
+    entity::{EntityRef, PrimaryMap},
+    target::{PointerWidth, Target},
 };
-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
@@ -68,25 +74,28 @@ pub trait Tunables {
         memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
         memory_definition_locations: &[NonNull<VMMemoryDefinition>],
     ) -> Result<PrimaryMap<LocalMemoryIndex, InternalStoreHandle<VMMemory>>, LinkError> {
-        let num_imports = module.num_imported_memories;
-        let mut memories: PrimaryMap<LocalMemoryIndex, _> =
-            PrimaryMap::with_capacity(module.memories.len() - num_imports);
-        for (index, mdl) in memory_definition_locations
-            .iter()
-            .enumerate()
-            .take(module.memories.len())
-            .skip(num_imports)
-        {
-            let mi = MemoryIndex::new(index);
-            let ty = &module.memories[mi];
-            let style = &memory_styles[mi];
-            memories.push(InternalStoreHandle::new(
-                context,
-                self.create_vm_memory(ty, style, *mdl)
-                    .map_err(|e| LinkError::Resource(format!("Failed to create memory: {}", e)))?,
-            ));
+        unsafe {
+            let num_imports = module.num_imported_memories;
+            let mut memories: PrimaryMap<LocalMemoryIndex, _> =
+                PrimaryMap::with_capacity(module.memories.len() - num_imports);
+            for (index, mdl) in memory_definition_locations
+                .iter()
+                .enumerate()
+                .take(module.memories.len())
+                .skip(num_imports)
+            {
+                let mi = MemoryIndex::new(index);
+                let ty = &module.memories[mi];
+                let style = &memory_styles[mi];
+                memories.push(InternalStoreHandle::new(
+                    context,
+                    self.create_vm_memory(ty, style, *mdl).map_err(|e| {
+                        LinkError::Resource(format!("Failed to create memory: {e}"))
+                    })?,
+                ));
+            }
+            Ok(memories)
         }
-        Ok(memories)
     }
 
     /// Allocate memory for just the tables of the current module.
@@ -102,25 +111,27 @@ pub trait Tunables {
         table_styles: &PrimaryMap<TableIndex, TableStyle>,
         table_definition_locations: &[NonNull<VMTableDefinition>],
     ) -> Result<PrimaryMap<LocalTableIndex, InternalStoreHandle<VMTable>>, LinkError> {
-        let num_imports = module.num_imported_tables;
-        let mut tables: PrimaryMap<LocalTableIndex, _> =
-            PrimaryMap::with_capacity(module.tables.len() - num_imports);
-        for (index, tdl) in table_definition_locations
-            .iter()
-            .enumerate()
-            .take(module.tables.len())
-            .skip(num_imports)
-        {
-            let ti = TableIndex::new(index);
-            let ty = &module.tables[ti];
-            let style = &table_styles[ti];
-            tables.push(InternalStoreHandle::new(
-                context,
-                self.create_vm_table(ty, style, *tdl)
-                    .map_err(LinkError::Resource)?,
-            ));
+        unsafe {
+            let num_imports = module.num_imported_tables;
+            let mut tables: PrimaryMap<LocalTableIndex, _> =
+                PrimaryMap::with_capacity(module.tables.len() - num_imports);
+            for (index, tdl) in table_definition_locations
+                .iter()
+                .enumerate()
+                .take(module.tables.len())
+                .skip(num_imports)
+            {
+                let ti = TableIndex::new(index);
+                let ty = &module.tables[ti];
+                let style = &table_styles[ti];
+                tables.push(InternalStoreHandle::new(
+                    context,
+                    self.create_vm_table(ty, style, *tdl)
+                        .map_err(LinkError::Resource)?,
+                ));
+            }
+            Ok(tables)
         }
-        Ok(tables)
     }
 
     /// Allocate memory for just the globals of the current module,
@@ -260,7 +271,7 @@ impl Tunables for BaseTunables {
         style: &MemoryStyle,
         vm_definition_location: NonNull<VMMemoryDefinition>,
     ) -> Result<VMMemory, MemoryError> {
-        VMMemory::from_definition(ty, style, vm_definition_location)
+        unsafe { VMMemory::from_definition(ty, style, vm_definition_location) }
     }
 
     /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
@@ -279,7 +290,7 @@ impl Tunables for BaseTunables {
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
     ) -> Result<VMTable, String> {
-        VMTable::from_definition(ty, style, vm_definition_location)
+        unsafe { VMTable::from_definition(ty, style, vm_definition_location) }
     }
 }
 
@@ -306,8 +317,10 @@ impl Tunables for Box<dyn Tunables + Send + Sync> {
         style: &MemoryStyle,
         vm_definition_location: NonNull<VMMemoryDefinition>,
     ) -> Result<VMMemory, MemoryError> {
-        self.as_ref()
-            .create_vm_memory(ty, style, vm_definition_location)
+        unsafe {
+            self.as_ref()
+                .create_vm_memory(ty, style, vm_definition_location)
+        }
     }
 
     fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
@@ -320,8 +333,10 @@ impl Tunables for Box<dyn Tunables + Send + Sync> {
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
     ) -> Result<VMTable, String> {
-        self.as_ref()
-            .create_vm_table(ty, style, vm_definition_location)
+        unsafe {
+            self.as_ref()
+                .create_vm_table(ty, style, vm_definition_location)
+        }
     }
 }
 
@@ -348,8 +363,10 @@ impl Tunables for std::sync::Arc<dyn Tunables + Send + Sync> {
         style: &MemoryStyle,
         vm_definition_location: NonNull<VMMemoryDefinition>,
     ) -> Result<VMMemory, MemoryError> {
-        self.as_ref()
-            .create_vm_memory(ty, style, vm_definition_location)
+        unsafe {
+            self.as_ref()
+                .create_vm_memory(ty, style, vm_definition_location)
+        }
     }
 
     fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
@@ -362,7 +379,9 @@ impl Tunables for std::sync::Arc<dyn Tunables + Send + Sync> {
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
     ) -> Result<VMTable, String> {
-        self.as_ref()
-            .create_vm_table(ty, style, vm_definition_location)
+        unsafe {
+            self.as_ref()
+                .create_vm_table(ty, style, vm_definition_location)
+        }
     }
 }
diff --git a/lib/compiler/src/engine/unwind/systemv.rs b/lib/compiler/src/engine/unwind/systemv.rs
index 3b0f06a5ce..11ef2ad9eb 100644
--- a/lib/compiler/src/engine/unwind/systemv.rs
+++ b/lib/compiler/src/engine/unwind/systemv.rs
@@ -3,22 +3,33 @@
 
 //! Module for System V ABI unwind registry.
 
-use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use core::sync::atomic::{
+    AtomicBool, AtomicUsize,
+    Ordering::{self, Relaxed},
+};
+use std::sync::Once;
 
-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(not(all(target_os = "macos", target_arch = "aarch64")))]
+    registrations: Vec<usize>,
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    compact_unwind_mgr: compact_unwind::CompactUnwindManager,
 }
 
-extern "C" {
+unsafe extern "C" {
     // libunwind import
     fn __register_frame(fde: *const u8);
     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
@@ -35,6 +46,7 @@ extern "C" {
 /// I'll note that there's also a different libunwind project at
 /// https://www.nongnu.org/libunwind/ but that doesn't appear to have
 /// `__register_frame` so I don't think that interacts with this.
+#[allow(dead_code)]
 fn using_libunwind() -> bool {
     static USING_LIBUNWIND: AtomicUsize = AtomicUsize::new(LIBUNWIND_UNKNOWN);
 
@@ -47,6 +59,12 @@ fn using_libunwind() -> bool {
         return true;
     }
 
+    // TODO: wasmtime started using weak symbol definition that makes the detection
+    // more reliable on linux-musl target: https://github.com/bytecodealliance/wasmtime/pull/9479
+    if cfg!(target_env = "musl") {
+        return true;
+    }
+
     // On other platforms the unwinder can vary. Sometimes the unwinder is
     // selected at build time and sometimes it differs at build time and runtime
     // (or at least I think that's possible). Fall back to a `libc::dlsym` to
@@ -61,7 +79,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()
             };
@@ -82,9 +100,23 @@ fn using_libunwind() -> bool {
 impl UnwindRegistry {
     /// Creates a new unwind registry with the given base address.
     pub fn new() -> Self {
+        // Register atexit handler that will tell us if exit has been called.
+        static INIT: Once = Once::new();
+        INIT.call_once(|| unsafe {
+            let result = libc::atexit(atexit_handler);
+            assert_eq!(result, 0, "libc::atexit must succeed");
+        });
+        assert!(
+            !EXIT_CALLED.load(Ordering::SeqCst),
+            "Cannot register unwind information during the process exit"
+        );
+
         Self {
-            registrations: Vec::new(),
             published: false,
+            #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+            registrations: Vec::new(),
+            #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+            compact_unwind_mgr: Default::default(),
         }
     }
 
@@ -103,15 +135,16 @@ impl UnwindRegistry {
         Ok(())
     }
 
-    /// Publishes all registered functions.
-    pub fn publish(&mut self, eh_frame: Option<&[u8]>) -> Result<(), String> {
+    /// Publishes all registered functions (coming from .eh_frame sections).
+    #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+    pub fn publish_eh_frame(&mut self, eh_frame: Option<&[u8]>) -> Result<(), String> {
         if self.published {
             return Err("unwind registry has already been published".to_string());
         }
 
-        if let Some(eh_frame) = eh_frame {
-            unsafe {
-                self.register_frames(eh_frame);
+        unsafe {
+            if let Some(eh_frame) = eh_frame {
+                self.register_eh_frames(eh_frame);
             }
         }
 
@@ -121,62 +154,138 @@ 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(not(all(target_os = "macos", target_arch = "aarch64")))]
+    unsafe fn register_eh_frames(&mut self, eh_frame: &[u8]) {
+        {
+            // 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;
+            let using_libunwind = using_libunwind();
+            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);
+                    }
+                } else {
+                    // For libgcc based systems, `__register_frame` takes a pointer to a CIE.
+                    if is_cie {
+                        records_to_register.push(record);
+                    }
+                }
+            }
 
-                // Move to the next table entry (+4 because the length itself is not inclusive)
-                current = current.add(len + 4);
+            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
+                unsafe {
+                    __register_frame(record as *const u8);
+                }
+                self.registrations.push(record);
             }
         }
     }
+
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    pub(crate) fn publish_compact_unwind(
+        &mut self,
+        compact_unwind: &[u8],
+        eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), String> {
+        if self.published {
+            return Err("unwind registry has already been published".to_string());
+        }
+
+        unsafe {
+            self.compact_unwind_mgr.read_compact_unwind_section(
+                compact_unwind.as_ptr() as _,
+                compact_unwind.len(),
+                eh_personality_addr_in_got,
+            )?;
+            self.compact_unwind_mgr
+                .finalize()
+                .map_err(|v| v.to_string())?;
+            self.compact_unwind_mgr.register();
+        }
+
+        self.published = true;
+        Ok(())
+    }
+}
+
+/// Global flag indicating whether the program exit has been initiated.
+/// Set to true by an atexit handler to prevent crashes during shutdown
+/// when deregistering unwind frames. Accesses use `Ordering::SeqCst`
+/// to ensure correct memory ordering across threads.
+pub static EXIT_CALLED: AtomicBool = AtomicBool::new(false);
+
+extern "C" fn atexit_handler() {
+    EXIT_CALLED.store(true, Ordering::SeqCst);
 }
 
 impl Drop for UnwindRegistry {
     fn drop(&mut self) {
         if self.published {
-            unsafe {
-                // libgcc stores the frame entries as a linked list in decreasing sort order
-                // based on the PC value of the registered entry.
-                //
-                // As we store the registrations in increasing order, it would be O(N^2) to
-                // deregister in that order.
-                //
-                // 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 _);
+            #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+            // libgcc stores the frame entries as a linked list in decreasing sort order
+            // based on the PC value of the registered entry.
+            //
+            // As we store the registrations in increasing order, it would be O(N^2) to
+            // deregister in that order.
+            //
+            // To ensure that we just pop off the first element in the list upon every
+            // deregistration, walk our list of registrations backwards.
+            for registration in self.registrations.iter().rev() {
+                // We don't want to deregister frames in UnwindRegistry::Drop as that could be called during
+                // program shutdown and can collide with release_registered_frames and lead to
+                // crashes.
+                if EXIT_CALLED.load(Ordering::SeqCst) {
+                    return;
+                }
+
+                unsafe {
+                    __deregister_frame(*registration as *const _);
+                }
+            }
+
+            #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+            {
+                if EXIT_CALLED.load(Ordering::SeqCst) {
+                    return;
                 }
+                self.compact_unwind_mgr.deregister();
             }
         }
     }
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..667ff7b110
--- /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 = unsafe { reader.read::<usize>() };
+        let length = unsafe { reader.read::<u32>() };
+        let compact_encoding = unsafe { reader.read::<u32>() };
+        let personality_addr = unsafe { reader.read::<usize>() };
+        let lsda_addr = unsafe { 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..c87d5b0062
--- /dev/null
+++ b/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
@@ -0,0 +1,537 @@
+/// 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 rangemap::RangeMap;
+use std::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;
+
+unsafe 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 UNWIND_INFO: LazyLock<Mutex<RangeMap<usize, UnwindInfoEntry>>> =
+    LazyLock::new(|| Mutex::new(RangeMap::new()));
+
+#[derive(Debug, Clone, PartialEq)]
+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 {
+    let Some(info) = (unsafe { info.as_mut() }) else {
+        return 0;
+    };
+
+    if let Some(entry) = UNWIND_INFO
+        .lock()
+        .expect("cannot lock UNWIND_INFO")
+        .get(&addr)
+    {
+        info.compact_unwind_section = entry.section_ptr as u64;
+        info.compact_unwind_section_length = entry.section_len as u64;
+        info.dwarf_section = 0;
+        info.dwarf_section_length = 0;
+        info.dso_base = entry.dso_base as u64;
+
+        1
+    } else {
+        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 = unsafe {
+                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;
+
+        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;
+
+        let mut uw_info = UNWIND_INFO.lock().expect("cannot lock UNWIND_INFO");
+        for range in ranges {
+            (*uw_info).insert(
+                range,
+                UnwindInfoEntry {
+                    dso_base,
+                    section_ptr,
+                    section_len,
+                },
+            );
+        }
+
+        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(())
+    }
+
+    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(())
+    }
+
+    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 {
+            let ranges: Vec<Range<usize>> = self
+                .compact_unwind_entries
+                .iter()
+                .map(|v| v.function_addr..v.function_addr + (v.length as usize))
+                .collect();
+            let mut uw_info = UNWIND_INFO.lock().expect("cannot lock UNWIND_INFO");
+            for range in ranges {
+                (*uw_info).remove(range);
+            }
+        }
+    }
+
+    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..1d764db9e9 100644
--- a/lib/compiler/src/engine/unwind/windows_x64.rs
+++ b/lib/compiler/src/engine/unwind/windows_x64.rs
@@ -2,10 +2,10 @@
 // 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,
+    IMAGE_RUNTIME_FUNCTION_ENTRY, RtlAddFunctionTable, RtlDeleteFunctionTable,
 };
 
 /// Represents a registry of function unwind information for Windows x64 ABI.
@@ -49,7 +49,7 @@ impl UnwindRegistry {
         // The unwind information should be immediately following the function
         // with padding for 4 byte alignment
         entry.Anonymous.UnwindInfoAddress = (entry.EndAddress + 3) & !3;
-        let entries = self.functions.entry(base_address).or_insert_with(Vec::new);
+        let entries = self.functions.entry(base_address).or_default();
 
         entries.push(entry);
 
@@ -57,7 +57,7 @@ impl UnwindRegistry {
     }
 
     /// Publishes all registered functions.
-    pub fn publish(&mut self, _eh_frame: Option<&[u8]>) -> Result<(), String> {
+    pub fn publish_eh_frame(&mut self, _eh_frame: Option<&[u8]>) -> Result<(), String> {
         if self.published {
             return Err("unwind registry has already been published".to_string());
         }
@@ -73,12 +73,11 @@ impl UnwindRegistry {
                     "function table allocation was not aligned"
                 );
                 unsafe {
-                    if RtlAddFunctionTable(
+                    if !RtlAddFunctionTable(
                         functions.as_mut_ptr(),
                         functions.len() as u32,
                         *base_address as u64,
-                    ) == 0
-                    {
+                    ) {
                         return Err("failed to register function tables".to_string());
                     }
                 }
diff --git a/lib/compiler/src/lib.rs b/lib/compiler/src/lib.rs
index 0afb951435..46e2c60c04 100644
--- a/lib/compiler/src/lib.rs
+++ b/lib/compiler/src/lib.rs
@@ -18,7 +18,19 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+macro_rules! cfg_std_or_core {
+    ($($item:item)*) => {
+        $(
+            #[cfg(any(
+                feature = "std",
+                feature = "core",
+            ))]
+            $item
+        )*
+    };
+}
 
 #[cfg(all(feature = "std", feature = "core"))]
 compile_error!(
@@ -32,6 +44,7 @@ compile_error!("Both the `std` and `core` features are disabled. Please enable o
 extern crate alloc;
 
 #[allow(unused_imports)]
+#[cfg(any(feature = "std", feature = "core"))]
 mod lib {
     #[cfg(feature = "core")]
     pub mod std {
@@ -46,30 +59,43 @@ mod lib {
     }
 }
 
-mod engine;
-mod traits;
+cfg_std_or_core! {
+    mod engine;
+    mod traits;
 
-pub use crate::engine::*;
-pub use crate::traits::*;
+    pub mod misc;
+    pub mod object;
+    pub mod progress;
+    pub mod serialize;
+    pub mod types;
 
-mod artifact_builders;
+    pub use crate::engine::*;
+    pub use crate::traits::*;
 
-pub use self::artifact_builders::*;
+    mod artifact_builders;
 
-#[cfg(feature = "translator")]
+    pub use self::artifact_builders::*;
+}
+
+#[cfg(feature = "compiler")]
 mod compiler;
+#[cfg(feature = "compiler")]
+pub use crate::compiler::{Compiler, CompilerConfig};
+
+#[cfg(feature = "compiler")]
+mod constants;
+#[cfg(feature = "compiler")]
+pub use crate::constants::*;
 
 #[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,
     MiddlewareReaderState, ModuleEnvironment, ModuleMiddleware, ModuleMiddlewareChain,
-    ModuleTranslationState,
+    ModuleTranslationState, from_binaryreadererror_wasmerror, translate_module, wpheaptype_to_type,
+    wptype_to_type,
 };
 
 pub use wasmer_types::{Addend, CodeOffset, Features};
diff --git a/lib/compiler/src/misc.rs b/lib/compiler/src/misc.rs
new file mode 100644
index 0000000000..3511b6baac
--- /dev/null
+++ b/lib/compiler/src/misc.rs
@@ -0,0 +1,240 @@
+//! A common functionality used among various compilers.
+
+use core::fmt::Display;
+use std::{collections::HashMap, path::PathBuf};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::process::{Command, Stdio};
+
+use itertools::Itertools;
+use target_lexicon::Architecture;
+use wasmer_types::{CompileError, FunctionType, LocalFunctionIndex, Type};
+
+#[cfg(not(target_arch = "wasm32"))]
+use tempfile::NamedTempFile;
+
+/// Represents the kind of compiled function or module, used for debugging and identification
+/// purposes across multiple compiler backends (e.g., LLVM, Cranelift).
+#[derive(Debug, Clone)]
+pub enum CompiledKind {
+    /// A locally-defined function in the Wasm file.
+    Local(LocalFunctionIndex, String),
+    /// A function call trampoline for a given signature.
+    FunctionCallTrampoline(FunctionType),
+    /// A dynamic function trampoline for a given signature.
+    DynamicFunctionTrampoline(FunctionType),
+    /// An entire Wasm module.
+    Module,
+}
+
+/// Converts a slice of `Type` into a string signature, mapping each type to a specific character.
+/// Used to represent function signatures in a compact string form.
+pub fn types_to_signature(types: &[Type]) -> String {
+    let tokens = types
+        .iter()
+        .map(|ty| match ty {
+            Type::I32 => "i",
+            Type::I64 => "I",
+            Type::F32 => "f",
+            Type::F64 => "F",
+            Type::V128 => "v",
+            Type::ExternRef => "e",
+            Type::FuncRef => "r",
+            Type::ExceptionRef => "x",
+        })
+        .collect_vec();
+    // Apparently, LLVM has issues if the filename is too long, thus we compact it.
+    tokens
+        .chunk_by(|a, b| a == b)
+        .map(|chunk| {
+            if chunk.len() >= 8 {
+                format!("{}x{}", chunk.len(), chunk[0])
+            } else {
+                chunk.to_owned().join("")
+            }
+        })
+        .join("")
+}
+
+/// Sanitizes a string so it can be safely used as a filename.
+fn sanitize_filename(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            if c.is_alphanumeric() || c == '_' || c == '-' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+/// Converts a kind into a filename, that we will use to dump
+/// the contents of the IR object file to.
+pub fn function_kind_to_filename(kind: &CompiledKind, suffix: &str) -> String {
+    match kind {
+        CompiledKind::Local(local_func_index, name) => {
+            let mut name = sanitize_filename(name);
+
+            // Limit to 255 characters to comply with common filesystem path component restrictions.
+            const PATH_LIMIT: usize = 255;
+
+            if name.len() + suffix.len() > PATH_LIMIT {
+                let id_string = local_func_index.as_u32().to_string();
+                name.truncate(PATH_LIMIT - id_string.len() - suffix.len() - 1);
+                name.push('_');
+                name.push_str(&id_string);
+                name.push_str(suffix);
+            } else {
+                name.push_str(suffix);
+            }
+
+            debug_assert!(name.len() <= PATH_LIMIT);
+            name
+        }
+        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+            "trampoline_call_{}_{}{suffix}",
+            types_to_signature(func_type.params()),
+            types_to_signature(func_type.results())
+        ),
+        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+            "trampoline_dynamic_{}_{}{suffix}",
+            types_to_signature(func_type.params()),
+            types_to_signature(func_type.results())
+        ),
+        CompiledKind::Module => "module".into(),
+    }
+}
+
+/// Saves disassembled assembly code to a file with optional comments at specific offsets.
+///
+/// This function takes raw machine code bytes, disassembles them using `objdump`, and writes
+/// the annotated assembly to a file in the specified debug directory.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn save_assembly_to_file<C: Display>(
+    arch: Architecture,
+    path: PathBuf,
+    body: &[u8],
+    assembly_comments: HashMap<usize, C>,
+) -> Result<(), CompileError> {
+    use std::{fs::File, io::Write};
+    use which::which;
+
+    #[derive(Debug)]
+    struct DecodedInsn<'a> {
+        offset: usize,
+        insn: &'a str,
+    }
+
+    fn parse_instructions(content: &str) -> Result<Vec<DecodedInsn<'_>>, CompileError> {
+        content
+            .lines()
+            .map(|line| line.trim())
+            .skip_while(|l| !l.starts_with("0000000000000000"))
+            .skip(1)
+            .filter(|line| line.trim() != "...")
+            .map(|line| -> Result<DecodedInsn<'_>, CompileError> {
+                let (offset, insn_part) = line.split_once(':').ok_or(CompileError::Codegen(
+                    format!("cannot parse objdump line: '{line}'"),
+                ))?;
+                // instruction content can be empty
+                let insn = insn_part
+                    .trim()
+                    .split_once('\t')
+                    .map_or("", |(_data, insn)| insn)
+                    .trim();
+                Ok(DecodedInsn {
+                    offset: usize::from_str_radix(offset, 16).map_err(|err| {
+                        CompileError::Codegen(format!("hex number expected: {err}"))
+                    })?,
+                    insn,
+                })
+            })
+            .collect()
+    }
+
+    // Note objdump cannot read from stdin.
+    let mut tmpfile = NamedTempFile::new()
+        .map_err(|err| CompileError::Codegen(format!("cannot create temporary file: {err}")))?;
+    tmpfile
+        .write_all(body)
+        .map_err(|err| CompileError::Codegen(format!("assembly dump write failed: {err}")))?;
+    tmpfile
+        .flush()
+        .map_err(|err| CompileError::Codegen(format!("flush failed: {err}")))?;
+
+    let (objdump_arch, objdump_binary) = match arch {
+        Architecture::X86_64 => ("i386:x86-64", "x86_64-linux-gnu-objdump"),
+        Architecture::Aarch64(..) => ("aarch64", "aarch64-linux-gnu-objdump"),
+        Architecture::Riscv64(..) => ("riscv:rv64", "riscv64-linux-gnu-objdump"),
+        _ => {
+            return Err(CompileError::Codegen(
+                "Assembly dumping is not supported for this architecture".to_string(),
+            ));
+        }
+    };
+
+    let bins = [objdump_binary, "objdump"];
+    let objdump_binary = bins.iter().find(|bin| which(bin).is_ok());
+    let Some(objdump_binary) = objdump_binary else {
+        // Objdump is an optional dependency, do not fail if not present.
+        return Ok(());
+    };
+
+    let command = Command::new(objdump_binary)
+        .arg("-b")
+        .arg("binary")
+        .arg("-m")
+        .arg(objdump_arch)
+        .arg("-D")
+        .arg(tmpfile.path())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn();
+
+    let Ok(command) = command else {
+        // The target might not be supported, do not fail in that case.
+        return Ok(());
+    };
+
+    let output = command
+        .wait_with_output()
+        .map_err(|err| CompileError::Codegen(format!("failed to read stdout: {err}")))?;
+    let content = String::from_utf8_lossy(&output.stdout);
+
+    let parsed_instructions = parse_instructions(content.as_ref())?;
+
+    let mut file = File::create(path).map_err(|err| {
+        CompileError::Codegen(format!("debug object file creation failed: {err}"))
+    })?;
+
+    // Dump the instruction annotated with the comments.
+    for insn in parsed_instructions {
+        if let Some(comment) = assembly_comments.get(&insn.offset) {
+            file.write_all(format!("      \t\t;; {comment}\n").as_bytes())
+                .map_err(|err| {
+                    CompileError::Codegen(format!("cannot write content to object file: {err}"))
+                })?;
+        }
+        file.write_all(format!("{:6x}:\t\t{}\n", insn.offset, insn.insn).as_bytes())
+            .map_err(|err| {
+                CompileError::Codegen(format!("cannot write content to object file: {err}"))
+            })?;
+    }
+
+    Ok(())
+}
+
+/// Saves disassembled assembly code to a file with optional comments at specific offsets.
+///
+/// This function takes raw machine code bytes, disassembles them using `objdump`, and writes
+/// the annotated assembly to a file in the specified debug directory.
+#[cfg(target_arch = "wasm32")]
+pub fn save_assembly_to_file<C: Display>(
+    _arch: Architecture,
+    _path: PathBuf,
+    _body: &[u8],
+    _assembly_comments: HashMap<usize, C>,
+) -> Result<(), CompileError> {
+    Ok(())
+}
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 75%
rename from lib/object/src/lib.rs
rename to lib/compiler/src/object/mod.rs
index 946101e966..69b92928f1 100644
--- a/lib/object/src/lib.rs
+++ b/lib/compiler/src/object/mod.rs
@@ -15,11 +15,13 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 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::{
+    ObjectMetadataBuilder, emit_compilation, emit_data, emit_serialized, get_object_for_target,
+};
 pub use object::{self, write::Object};
diff --git a/lib/compiler/src/object/module.rs b/lib/compiler/src/object/module.rs
new file mode 100644
index 0000000000..e38c70ccf7
--- /dev/null
+++ b/lib/compiler/src/object/module.rs
@@ -0,0 +1,803 @@
+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::{
+    FileFlags, RelocationEncoding, RelocationFlags, RelocationKind, SectionKind, SymbolFlags,
+    SymbolKind, SymbolScope, elf, macho,
+    write::{
+        Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolId,
+        SymbolSection,
+    },
+};
+use wasmer_types::LocalFunctionIndex;
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::{Architecture, BinaryFormat, Endianness, PointerWidth, Triple};
+
+const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
+
+/// Create an object for a given target `Triple`.
+///
+/// # Usage
+///
+/// ```rust
+/// # 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)?;
+///
+/// # Ok(())
+/// # }
+/// ```
+pub fn get_object_for_target(triple: &Triple) -> Result<Object<'static>, ObjectError> {
+    let obj_binary_format = match triple.binary_format {
+        BinaryFormat::Elf => object::BinaryFormat::Elf,
+        BinaryFormat::Macho => object::BinaryFormat::MachO,
+        BinaryFormat::Coff => object::BinaryFormat::Coff,
+        binary_format => {
+            return Err(ObjectError::UnsupportedBinaryFormat(format!(
+                "{binary_format}"
+            )));
+        }
+    };
+    let obj_architecture = match triple.architecture {
+        Architecture::X86_64 => object::Architecture::X86_64,
+        Architecture::Aarch64(_) => object::Architecture::Aarch64,
+        Architecture::Riscv64(_) => object::Architecture::Riscv64,
+        Architecture::Riscv32(_) => object::Architecture::Riscv32,
+        Architecture::LoongArch64 => object::Architecture::LoongArch64,
+        architecture => {
+            return Err(ObjectError::UnsupportedArchitecture(format!(
+                "{architecture}"
+            )));
+        }
+    };
+    let obj_endianness = match triple
+        .endianness()
+        .map_err(|_| ObjectError::UnknownEndianness)?
+    {
+        Endianness::Little => object::Endianness::Little,
+        Endianness::Big => object::Endianness::Big,
+    };
+
+    let mut object = Object::new(obj_binary_format, obj_architecture, obj_endianness);
+
+    if let Architecture::Riscv64(_) = triple.architecture {
+        object.flags = FileFlags::Elf {
+            e_flags: elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+            os_abi: 2,
+            abi_version: 0,
+        };
+    }
+
+    Ok(object)
+}
+
+/// Write data into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # 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)?;
+/// emit_data(&mut object, b"WASMER_METADATA", &b"Hello, World!"[..], 1)?;
+///
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_data(
+    obj: &mut Object,
+    name: &[u8],
+    data: &[u8],
+    align: u64,
+) -> Result<u64, ObjectError> {
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: name.to_vec(),
+        value: 0,
+        size: 0,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Undefined,
+        flags: SymbolFlags::None,
+    });
+    let section_id = obj.section_id(StandardSection::Data);
+    let offset = obj.add_symbol_data(symbol_id, section_id, data, align);
+
+    Ok(offset)
+}
+
+/// Emit the compilation result into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # 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, &builder)?;
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_compilation(
+    obj: &mut Object,
+    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());
+    for (_, func) in compilation.functions.into_iter() {
+        function_bodies.push(func.body);
+        function_relocations.push(func.relocations);
+    }
+    let custom_section_relocations = compilation
+        .custom_sections
+        .iter()
+        .map(|(_, section)| section.relocations.clone())
+        .collect::<PrimaryMap<SectionIndex, _>>();
+
+    let debug_index = compilation.unwind_info.eh_frame;
+
+    let default_align = match triple.architecture {
+        target_lexicon::Architecture::Aarch64(_) => {
+            if matches!(
+                triple.operating_system,
+                target_lexicon::OperatingSystem::Darwin(_)
+            ) {
+                8
+            } else {
+                4
+            }
+        }
+        _ => 1,
+    };
+
+    // Add sections
+    let custom_section_ids = compilation
+        .custom_sections
+        .into_iter()
+        .map(|(section_index, custom_section)| {
+            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(), 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(),
+                    value: 0,
+                    size: custom_section.bytes.len() as _,
+                    kind: SymbolKind::Data,
+                    scope: SymbolScope::Compilation,
+                    weak: false,
+                    section: SymbolSection::Section(section_id),
+                    flags: SymbolFlags::None,
+                });
+                (section_id, symbol_id)
+            } else {
+                let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
+                let (section_kind, standard_section) = match custom_section.protection {
+                    CustomSectionProtection::ReadExecute => {
+                        (SymbolKind::Text, StandardSection::Text)
+                    }
+                    CustomSectionProtection::Read => (SymbolKind::Data, StandardSection::Data),
+                };
+                let section_id = obj.section_id(standard_section);
+                let symbol_id = obj.add_symbol(ObjSymbol {
+                    name: section_name.into_bytes(),
+                    value: 0,
+                    size: custom_section.bytes.len() as _,
+                    kind: section_kind,
+                    scope: SymbolScope::Dynamic,
+                    weak: false,
+                    section: SymbolSection::Section(section_id),
+                    flags: SymbolFlags::None,
+                });
+                obj.add_symbol_data(
+                    symbol_id,
+                    section_id,
+                    custom_section.bytes.as_slice(),
+                    custom_section.alignment.unwrap_or(default_align),
+                );
+                (section_id, symbol_id)
+            }
+        })
+        .collect::<PrimaryMap<SectionIndex, _>>();
+
+    // Add functions
+    let function_symbol_ids = function_bodies
+        .into_iter()
+        .map(|(function_local_index, function)| {
+            let function_name =
+                symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
+            let section_id = obj.section_id(StandardSection::Text);
+            let symbol_id = obj.add_symbol(ObjSymbol {
+                name: function_name.into_bytes(),
+                value: 0,
+                size: function.body.len() as _,
+                kind: SymbolKind::Text,
+                scope: SymbolScope::Dynamic,
+                weak: false,
+                section: SymbolSection::Section(section_id),
+                flags: SymbolFlags::None,
+            });
+            let symbol_offset =
+                obj.add_symbol_data(symbol_id, section_id, &function.body, default_align);
+            (section_id, symbol_id, symbol_offset)
+        })
+        .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() {
+        let function_name =
+            symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(signature_index));
+        let section_id = obj.section_id(StandardSection::Text);
+        let symbol_id = obj.add_symbol(ObjSymbol {
+            name: function_name.into_bytes(),
+            value: 0,
+            size: function.body.len() as _,
+            kind: SymbolKind::Text,
+            scope: SymbolScope::Dynamic,
+            weak: false,
+            section: SymbolSection::Section(section_id),
+            flags: SymbolFlags::None,
+        });
+        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
+    for (func_index, function) in compilation.dynamic_function_trampolines.into_iter() {
+        let function_name =
+            symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
+        let section_id = obj.section_id(StandardSection::Text);
+        let symbol_id = obj.add_symbol(ObjSymbol {
+            name: function_name.into_bytes(),
+            value: 0,
+            size: function.body.len() as _,
+            kind: SymbolKind::Text,
+            scope: SymbolScope::Dynamic,
+            weak: false,
+            section: SymbolSection::Section(section_id),
+            flags: SymbolFlags::None,
+        });
+        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();
+
+    for (function_local_index, relocations) in function_relocations.into_iter() {
+        let (section_id, symbol_id, _) = function_symbol_ids.get(function_local_index).unwrap();
+        all_relocations.push((*section_id, *symbol_id, relocations))
+    }
+
+    for (section_index, relocations) in custom_section_relocations.into_iter() {
+        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));
+        }
+    }
+
+    for (section_id, symbol_id, relocations) in all_relocations.into_iter() {
+        let (_symbol_id, section_offset) = obj.symbol_section_and_offset(symbol_id).unwrap();
+
+        for r in relocations {
+            let relocation_address = section_offset + r.offset as u64;
+
+            let relocation_flags = match r.kind {
+                Reloc::Abs4 => RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: 32,
+                },
+                Reloc::Abs8 => RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: 64,
+                },
+                Reloc::PCRel4 => RelocationFlags::Generic {
+                    kind: RelocationKind::Relative,
+                    encoding: RelocationEncoding::Generic,
+                    size: 32,
+                },
+                Reloc::X86CallPCRel4 => RelocationFlags::Generic {
+                    kind: RelocationKind::Relative,
+                    encoding: RelocationEncoding::X86Branch,
+                    size: 32,
+                },
+                Reloc::X86CallPLTRel4 => RelocationFlags::Generic {
+                    kind: RelocationKind::PltRelative,
+                    encoding: RelocationEncoding::X86Branch,
+                    size: 32,
+                },
+                Reloc::X86GOTPCRel4 => RelocationFlags::Generic {
+                    kind: RelocationKind::GotRelative,
+                    encoding: RelocationEncoding::Generic,
+                    size: 32,
+                },
+                Reloc::Arm64Call => match obj.format() {
+                    object::BinaryFormat::Elf => RelocationFlags::Elf {
+                        r_type: elf::R_AARCH64_CALL26,
+                    },
+                    object::BinaryFormat::MachO => RelocationFlags::MachO {
+                        r_type: macho::ARM64_RELOC_BRANCH26,
+                        r_pcrel: true,
+                        r_length: 32,
+                    },
+                    fmt => panic!("unsupported binary format {fmt:?}"),
+                },
+                Reloc::ElfX86_64TlsGd => RelocationFlags::Elf {
+                    r_type: elf::R_X86_64_TLSGD,
+                },
+                Reloc::MachoArm64RelocBranch26 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_BRANCH26,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+
+                Reloc::MachoArm64RelocUnsigned => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_UNSIGNED,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocSubtractor => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_SUBTRACTOR,
+                    r_pcrel: false,
+                    r_length: 64,
+                },
+                Reloc::MachoArm64RelocPage21 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_PAGE21,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocPageoff12 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_PAGEOFF12,
+                    r_pcrel: false,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocGotLoadPage21 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_GOT_LOAD_PAGE21,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocGotLoadPageoff12 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocPointerToGot => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_POINTER_TO_GOT,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocTlvpLoadPage21 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_TLVP_LOAD_PAGE21,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocTlvpLoadPageoff12 => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
+                    r_pcrel: true,
+                    r_length: 32,
+                },
+                Reloc::MachoArm64RelocAddend => RelocationFlags::MachO {
+                    r_type: macho::ARM64_RELOC_ADDEND,
+                    r_pcrel: false,
+                    r_length: 32,
+                },
+                // For RISC-V relocations, please refer to:
+                // https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/2484f950a551c653f1823f1bd11926bf5a57fae3/riscv-elf.adoc#relocations
+                Reloc::RiscvPCRelHi20 => RelocationFlags::Elf {
+                    r_type: elf::R_RISCV_PCREL_HI20,
+                },
+                Reloc::RiscvPCRelLo12I => RelocationFlags::Elf {
+                    r_type: elf::R_RISCV_PCREL_LO12_I,
+                },
+                Reloc::RiscvCall => RelocationFlags::Elf {
+                    r_type: elf::R_RISCV_CALL_PLT,
+                },
+                other => {
+                    return Err(ObjectError::UnsupportedArchitecture(format!(
+                        "{} (relocation: {other:?})",
+                        triple.architecture
+                    )));
+                }
+            };
+
+            match r.reloc_target {
+                RelocationTarget::LocalFunc(index) => {
+                    let (target_section, target_symbol, target_symbol_offset) =
+                        function_symbol_ids.get(index).unwrap();
+                    if r.kind == Reloc::RiscvPCRelLo12I && r.addend != 0 {
+                        // R_RISCV_PCREL_LO12_I requires addend must be zero, lld would ignore
+                        // non-zero addend values, resulting in linking failures. We must create
+                        // new symbols for R_RISCV_PCREL_LO12_I targets(R_RISCV_PCREL_HI20 addresses).
+                        let function_name =
+                            symbol_registry.symbol_to_name(Symbol::LocalFunction(index));
+                        let hi_symbol_name = format!("{}_offset_{}", function_name, r.addend);
+                        let hi_symbol =
+                            obj.symbol_id(hi_symbol_name.as_bytes()).unwrap_or_else(|| {
+                                obj.add_symbol(ObjSymbol {
+                                    name: hi_symbol_name.as_bytes().to_vec(),
+                                    value: *target_symbol_offset + r.addend as u64,
+                                    size: 0,
+                                    kind: SymbolKind::Label,
+                                    scope: SymbolScope::Compilation,
+                                    weak: false,
+                                    section: SymbolSection::Section(*target_section),
+                                    flags: SymbolFlags::None,
+                                })
+                            });
+                        obj.add_relocation(
+                            section_id,
+                            Relocation {
+                                offset: relocation_address,
+                                flags: relocation_flags,
+                                symbol: hi_symbol,
+                                addend: 0,
+                            },
+                        )
+                        .map_err(ObjectError::Write)?;
+                    } else {
+                        obj.add_relocation(
+                            section_id,
+                            Relocation {
+                                offset: relocation_address,
+                                flags: relocation_flags,
+                                symbol: *target_symbol,
+                                addend: r.addend,
+                            },
+                        )
+                        .map_err(ObjectError::Write)?;
+                    }
+                }
+                RelocationTarget::DynamicTrampoline(_) => todo!("Not supported yet"),
+                RelocationTarget::LibCall(libcall) => {
+                    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 {
+                            name: libcall_fn_name.to_vec(),
+                            value: 0,
+                            size: 0,
+                            kind: SymbolKind::Unknown,
+                            scope: SymbolScope::Unknown,
+                            weak: false,
+                            section: SymbolSection::Undefined,
+                            flags: SymbolFlags::None,
+                        })
+                    });
+                    obj.add_relocation(
+                        section_id,
+                        Relocation {
+                            offset: relocation_address,
+                            flags: relocation_flags,
+                            symbol: target_symbol,
+                            addend: r.addend,
+                        },
+                    )
+                    .map_err(ObjectError::Write)?;
+                }
+                RelocationTarget::CustomSection(section_index) => {
+                    let (_, target_symbol) = custom_section_ids.get(section_index).unwrap();
+                    obj.add_relocation(
+                        section_id,
+                        Relocation {
+                            offset: relocation_address,
+                            flags: relocation_flags,
+                            symbol: *target_symbol,
+                            addend: r.addend,
+                        },
+                    )
+                    .map_err(ObjectError::Write)?;
+                }
+            };
+        }
+    }
+
+    Ok(())
+}
+
+/// Emit the compilation result into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # 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,
+/// #     compilation: Compilation,
+/// #     symbol_registry: impl SymbolRegistry,
+/// # ) -> Result<(), ObjectError> {
+/// let bytes = &[ /* compilation bytes */];
+/// let mut object = get_object_for_target(&triple)?;
+/// emit_serialized(&mut object, bytes, &triple, "WASMER_MODULE")?;
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_serialized(
+    obj: &mut Object,
+    sercomp: &[u8],
+    triple: &Triple,
+    object_name: &str,
+) -> Result<(), ObjectError> {
+    obj.set_mangling(object::write::Mangling::None);
+    //let module_name = module.compile_info.module.name.clone();
+    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 {
+        Architecture::X86_64 => 1,
+        // In Arm64 is recommended a 4-byte alignment
+        Architecture::Aarch64(_) => 4,
+        _ => 1,
+    };
+
+    let len = sercomp.len();
+    let section_id = obj.section_id(StandardSection::Data);
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: len_name.as_bytes().to_vec(),
+        value: 0,
+        size: len.to_le_bytes().len() as _,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Section(section_id),
+        flags: SymbolFlags::None,
+    });
+    obj.add_symbol_data(symbol_id, section_id, &len.to_le_bytes(), align);
+
+    let section_id = obj.section_id(StandardSection::Data);
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: data_name.as_bytes().to_vec(),
+        value: 0,
+        size: sercomp.len() as _,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Section(section_id),
+        flags: SymbolFlags::None,
+    });
+    obj.add_symbol_data(symbol_id, section_id, sercomp, align);
+
+    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),
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
+                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),
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
+                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),
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
+                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/progress.rs b/lib/compiler/src/progress.rs
new file mode 100644
index 0000000000..08a9a5250a
--- /dev/null
+++ b/lib/compiler/src/progress.rs
@@ -0,0 +1,49 @@
+//! Shared helpers for reporting compilation progress across the different backends.
+
+use crate::lib::std::{
+    borrow::Cow,
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
+};
+use wasmer_types::{CompilationProgress, CompilationProgressCallback, CompileError};
+
+/// Tracks progress within a compilation phase and forwards updates to a callback.
+///
+/// Convenience wrapper around a [`CompilationProgressCallback`] for the compilers.
+#[derive(Clone)]
+pub struct ProgressContext {
+    callback: CompilationProgressCallback,
+    counter: Arc<AtomicU64>,
+    total: u64,
+    phase_name: &'static str,
+}
+
+impl ProgressContext {
+    /// Creates a new [`ProgressContext`] for the given phase.
+    pub fn new(
+        callback: CompilationProgressCallback,
+        total: u64,
+        phase_name: &'static str,
+    ) -> Self {
+        Self {
+            callback,
+            counter: Arc::new(AtomicU64::new(0)),
+            total,
+            phase_name,
+        }
+    }
+
+    /// Notifies the callback that the next step in the phase has completed.
+    pub fn notify(&self) -> Result<(), CompileError> {
+        let step = self.counter.fetch_add(1, Ordering::SeqCst) + 1;
+        self.callback
+            .notify(CompilationProgress::new(
+                Some(Cow::Borrowed(self.phase_name)),
+                Some(self.total),
+                Some(step),
+            ))
+            .map_err(CompileError::from)
+    }
+}
diff --git a/lib/compiler/src/serialize.rs b/lib/compiler/src/serialize.rs
new file mode 100644
index 0000000000..3fd606b688
--- /dev/null
+++ b/lib/compiler/src/serialize.rs
@@ -0,0 +1,177 @@
+/*
+ * ! 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, GOT, UnwindInfo},
+    module::CompileModuleInfo,
+    relocation::Relocation,
+    section::{CustomSection, SectionIndex},
+};
+use enumset::EnumSet;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use wasmer_types::{
+    DeserializeError, Features, FunctionIndex, LocalFunctionIndex, MemoryIndex, MemoryStyle,
+    ModuleInfo, OwnedDataInitializer, SerializeError, SignatureIndex, TableIndex, TableStyle,
+    entity::PrimaryMap, target::CpuFeature,
+};
+
+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> {
+        unsafe {
+            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> {
+        unsafe { 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..62581f5c69 100644
--- a/lib/compiler/src/traits.rs
+++ b/lib/compiler/src/traits.rs
@@ -4,10 +4,11 @@ use crate::Features;
 use enumset::EnumSet;
 use std::any::Any;
 use std::sync::Arc;
-use wasmer_types::entity::PrimaryMap;
 use wasmer_types::SerializeError;
+use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
-    CpuFeature, DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+    DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+    target::CpuFeature,
 };
 
 /// 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..d82e3543f9 100644
--- a/lib/compiler/src/translator/environ.rs
+++ b/lib/compiler/src/translator/environ.rs
@@ -5,17 +5,18 @@ use crate::lib::std::string::ToString;
 use crate::lib::std::{boxed::Box, string::String, vec::Vec};
 use crate::translate_module;
 use crate::wasmparser::{Operator, ValType};
+use std::collections::HashMap;
 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::entity::PrimaryMap;
 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 +86,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 +153,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 +293,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 +351,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,
@@ -417,14 +467,11 @@ impl<'data> ModuleEnvironment<'data> {
         Ok(())
     }
 
-    pub(crate) fn declare_function_name(
+    pub(crate) fn declare_function_names(
         &mut self,
-        func_index: FunctionIndex,
-        name: &'data str,
+        functions: HashMap<FunctionIndex, String>,
     ) -> WasmResult<()> {
-        self.module
-            .function_names
-            .insert(func_index, name.to_string());
+        self.module.function_names = functions;
         Ok(())
     }
 
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..bd31df32be 100644
--- a/lib/compiler/src/translator/middleware.rs
+++ b/lib/compiler/src/translator/middleware.rs
@@ -5,8 +5,8 @@ use smallvec::SmallVec;
 use std::collections::VecDeque;
 use std::fmt::Debug;
 use std::ops::{Deref, Range};
-use wasmer_types::{LocalFunctionIndex, MiddlewareError, ModuleInfo, WasmResult};
-use wasmparser::{BinaryReader, Operator, ValType};
+use wasmer_types::{LocalFunctionIndex, MiddlewareError, ModuleInfo, WasmError, WasmResult};
+use wasmparser::{BinaryReader, FunctionBody, Operator, OperatorsReader, ValType};
 
 use super::error::from_binaryreadererror_wasmerror;
 use crate::translator::environ::FunctionBinaryReader;
@@ -46,7 +46,6 @@ pub trait FunctionMiddleware<'a>: Debug {
 }
 
 /// A Middleware binary reader of the WebAssembly structures and types.
-#[derive(Debug)]
 pub struct MiddlewareBinaryReader<'a> {
     /// Parsing state.
     state: MiddlewareReaderState<'a>,
@@ -55,11 +54,18 @@ pub struct MiddlewareBinaryReader<'a> {
     chain: Vec<Box<dyn FunctionMiddleware<'a> + 'a>>,
 }
 
+enum MiddlewareInnerReader<'a> {
+    Binary {
+        reader: BinaryReader<'a>,
+        original_reader: BinaryReader<'a>,
+    },
+    Operator(OperatorsReader<'a>),
+}
+
 /// The state of the binary reader. Exposed to middlewares to push their outputs.
-#[derive(Debug)]
 pub struct MiddlewareReaderState<'a> {
     /// Raw binary reader.
-    inner: BinaryReader<'a>,
+    inner: Option<MiddlewareInnerReader<'a>>,
 
     /// The pending operations added by the middleware.
     pending_operations: VecDeque<Operator<'a>>,
@@ -128,10 +134,13 @@ 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,
+                inner: Some(MiddlewareInnerReader::Binary {
+                    original_reader: inner.clone(),
+                    reader: inner,
+                }),
                 pending_operations: VecDeque::new(),
                 local_decls: 0,
                 local_decls_read: 0,
@@ -156,8 +165,15 @@ impl<'a> MiddlewareBinaryReader<'a> {
 
 impl<'a> FunctionBinaryReader<'a> for MiddlewareBinaryReader<'a> {
     fn read_local_count(&mut self) -> WasmResult<u32> {
-        let total = self.state.inner.read_var_u32();
-        let total = total.map_err(from_binaryreadererror_wasmerror)?;
+        let total = match self.state.inner.as_mut().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader
+                .read_var_u32()
+                .map_err(from_binaryreadererror_wasmerror),
+            MiddlewareInnerReader::Operator(..) => Err(WasmError::InvalidWebAssembly {
+                message: "locals must be read before the function body".to_string(),
+                offset: self.current_position(),
+            })
+        }?;
         self.state.local_decls = total;
         self.state.locals.reserve(total as usize);
         if total == 0 {
@@ -167,10 +183,21 @@ impl<'a> FunctionBinaryReader<'a> for MiddlewareBinaryReader<'a> {
     }
 
     fn read_local_decl(&mut self) -> WasmResult<(u32, ValType)> {
-        let count = self.state.inner.read_var_u32();
-        let count = count.map_err(from_binaryreadererror_wasmerror)?;
-        let ty = self.state.inner.read::<ValType>();
-        let ty = ty.map_err(from_binaryreadererror_wasmerror)?;
+        let (count, ty) = match self.state.inner.as_mut().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => {
+                let count = reader
+                    .read_var_u32()
+                    .map_err(from_binaryreadererror_wasmerror)?;
+                let ty: ValType = reader
+                    .read::<ValType>()
+                    .map_err(from_binaryreadererror_wasmerror)?;
+                Ok((count, ty))
+            }
+            MiddlewareInnerReader::Operator(..) => Err(WasmError::InvalidWebAssembly {
+                message: "locals must be read before the function body".to_string(),
+                offset: self.current_position(),
+            }),
+        }?;
         for _ in 0..count {
             self.state.locals.push(ty);
         }
@@ -183,22 +210,38 @@ impl<'a> FunctionBinaryReader<'a> for MiddlewareBinaryReader<'a> {
     }
 
     fn read_operator(&mut self) -> WasmResult<Operator<'a>> {
+        if let Some(inner) = self.state.inner.take() {
+            self.state.inner = Some(match inner {
+                MiddlewareInnerReader::Binary {
+                    original_reader, ..
+                } => {
+                    let operator_reader = FunctionBody::new(original_reader)
+                        .get_operators_reader()
+                        .map_err(from_binaryreadererror_wasmerror)?;
+                    MiddlewareInnerReader::Operator(operator_reader)
+                }
+                other => other,
+            });
+        }
+
+        let read_operator = |state: &mut MiddlewareReaderState<'a>| {
+            let Some(MiddlewareInnerReader::Operator(operator_reader)) = state.inner.as_mut()
+            else {
+                unreachable!();
+            };
+            operator_reader
+                .read()
+                .map_err(from_binaryreadererror_wasmerror)
+        };
+
         if self.chain.is_empty() {
             // We short-circuit in case no chain is used
-            return self
-                .state
-                .inner
-                .read_operator()
-                .map_err(from_binaryreadererror_wasmerror);
+            return read_operator(&mut self.state);
         }
 
         // Try to fill the `self.pending_operations` buffer, until it is non-empty.
         while self.state.pending_operations.is_empty() {
-            let raw_op = self
-                .state
-                .inner
-                .read_operator()
-                .map_err(from_binaryreadererror_wasmerror)?;
+            let raw_op = read_operator(&mut self.state)?;
 
             // Fill the initial raw operator into pending buffer.
             self.state.pending_operations.push_back(raw_op);
@@ -220,22 +263,43 @@ impl<'a> FunctionBinaryReader<'a> for MiddlewareBinaryReader<'a> {
     }
 
     fn current_position(&self) -> usize {
-        self.state.inner.current_position()
+        match self.state.inner.as_ref().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader.current_position(),
+            MiddlewareInnerReader::Operator(operator_reader) => {
+                operator_reader.get_binary_reader().current_position()
+            }
+        }
     }
 
     fn original_position(&self) -> usize {
-        self.state.inner.original_position()
+        match self.state.inner.as_ref().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader.original_position(),
+            MiddlewareInnerReader::Operator(operator_reader) => operator_reader.original_position(),
+        }
     }
 
     fn bytes_remaining(&self) -> usize {
-        self.state.inner.bytes_remaining()
+        match self.state.inner.as_ref().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader.bytes_remaining(),
+            MiddlewareInnerReader::Operator(operator_reader) => {
+                operator_reader.get_binary_reader().bytes_remaining()
+            }
+        }
     }
 
     fn eof(&self) -> bool {
-        self.state.inner.eof()
+        match self.state.inner.as_ref().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader.eof(),
+            MiddlewareInnerReader::Operator(operator_reader) => operator_reader.eof(),
+        }
     }
 
     fn range(&self) -> Range<usize> {
-        self.state.inner.range()
+        match self.state.inner.as_ref().expect("inner state must exist") {
+            MiddlewareInnerReader::Binary { reader, .. } => reader.range(),
+            MiddlewareInnerReader::Operator(operator_reader) => {
+                operator_reader.get_binary_reader().range()
+            }
+        }
     }
 }
diff --git a/lib/compiler/src/translator/module.rs b/lib/compiler/src/translator/module.rs
index 68c67f807c..0e7be73cbd 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..c0fea85213 100644
--- a/lib/compiler/src/translator/sections.rs
+++ b/lib/compiler/src/translator/sections.rs
@@ -14,22 +14,22 @@
 use super::environ::ModuleEnvironment;
 use super::error::from_binaryreadererror_wasmerror;
 use super::state::ModuleTranslationState;
-use crate::wasm_unsupported;
 use std::boxed::Box;
+use std::collections::{HashMap, HashSet};
 use std::vec::Vec;
-use wasmer_types::entity::packed_option::ReservedValue;
 use wasmer_types::entity::EntityRef;
+use wasmer_types::entity::packed_option::ReservedValue;
 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,
+    GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, Imports,
+    MemorySectionReader, 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:?}")),
     }
 }
@@ -111,6 +118,11 @@ pub fn parse_import_section<'data>(
 
     for entry in imports {
         let import = entry.map_err(from_binaryreadererror_wasmerror)?;
+        let Imports::Single(_index, import) = import else {
+            return Err(WasmError::Generic(
+                "non-Single section Imports not implemented yet".to_string(),
+            ));
+        };
         let module_name = import.module;
         let field_name = import.name;
 
@@ -122,14 +134,20 @@ pub fn parse_import_section<'data>(
                     field_name,
                 )?;
             }
-            TypeRef::Tag(_) => {
-                unimplemented!("exception handling not implemented yet")
+            TypeRef::FuncExact(_) => {
+                return Err(WasmError::Generic(
+                    "custom-descriptors not implemented yet".to_string(),
+                ));
+            }
+            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 +176,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 +196,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 +222,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 +243,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 +258,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,15 +282,17 @@ 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();
+        let mut init_expr_reader = init_expr.get_operators_reader();
         let initializer = match init_expr_reader
-            .read_operator()
+            .read()
             .map_err(from_binaryreadererror_wasmerror)?
         {
             Operator::I32Const { value } => GlobalInit::I32Const(value),
@@ -318,9 +354,8 @@ 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)?,
+            ExternalKind::FuncExact => unimplemented!("custom-descriptors not implemented yet"),
         }
     }
 
@@ -357,8 +392,8 @@ fn read_elems(items: &ElementItems) -> WasmResult<Box<[FunctionIndex]>> {
                 let expr = res.map_err(from_binaryreadererror_wasmerror)?;
 
                 let op = expr
-                    .get_binary_reader()
-                    .read_operator()
+                    .get_operators_reader()
+                    .read()
                     .map_err(from_binaryreadererror_wasmerror)?;
                 match op {
                     Operator::RefNull { .. } => out.push(FunctionIndex::reserved_value()),
@@ -400,9 +435,9 @@ pub fn parse_element_section(
             } => {
                 let table_index = TableIndex::from_u32(table_index.unwrap_or(0));
 
-                let mut init_expr_reader = offset_expr.get_binary_reader();
+                let mut init_expr_reader = offset_expr.get_operators_reader();
                 let (base, offset) = match init_expr_reader
-                    .read_operator()
+                    .read()
                     .map_err(from_binaryreadererror_wasmerror)?
                 {
                     Operator::I32Const { value } => (None, value as u32 as usize),
@@ -446,9 +481,9 @@ pub fn parse_data_section<'data>(
                 memory_index,
                 offset_expr,
             } => {
-                let mut init_expr_reader = offset_expr.get_binary_reader();
+                let mut init_expr_reader = offset_expr.get_operators_reader();
                 let (base, offset) = match init_expr_reader
-                    .read_operator()
+                    .read()
                     .map_err(from_binaryreadererror_wasmerror)?
                 {
                     Operator::I32Const { value } => (None, value as u32 as usize),
@@ -459,7 +494,7 @@ pub fn parse_data_section<'data>(
                         return Err(wasm_unsupported!(
                             "unsupported init expr in data section: {:?}",
                             s
-                        ))
+                        ));
                     }
                 };
                 environ.declare_data_initialization(
@@ -484,6 +519,9 @@ pub fn parse_name_section<'data>(
     names: NameSectionReader<'data>,
     environ: &mut ModuleEnvironment<'data>,
 ) -> WasmResult<()> {
+    let mut functions = HashMap::new();
+    let mut names_set = HashSet::new();
+
     for res in names {
         let subsection = if let Ok(subsection) = res {
             subsection
@@ -493,12 +531,21 @@ pub fn parse_name_section<'data>(
         };
         match subsection {
             wasmparser::Name::Function(function_subsection) => {
+                let mut unique_name_map = HashMap::new();
                 for naming in function_subsection.into_iter().flatten() {
-                    if naming.index != std::u32::MAX {
-                        environ.declare_function_name(
-                            FunctionIndex::from_u32(naming.index),
-                            naming.name,
-                        )?;
+                    if naming.index != u32::MAX {
+                        let mut name = naming.name.to_string();
+                        // In very rare cases a function name can have duplicates.
+                        if names_set.contains(&name) {
+                            let index = unique_name_map
+                                .entry(name.clone())
+                                .and_modify(|e| *e += 1)
+                                .or_insert(0);
+                            let alternative = format!("{name}.{index}");
+                            name = alternative;
+                        }
+                        names_set.insert(name.clone());
+                        functions.insert(FunctionIndex::from_u32(naming.index), name);
                     }
                 }
             }
@@ -517,9 +564,10 @@ pub fn parse_name_section<'data>(
             | wasmparser::Name::Element(_)
             | wasmparser::Name::Data(_)
             | wasmparser::Name::Unknown { .. }
+            | wasmparser::Name::Field(_)
             | wasmparser::Name::Tag(..) => {}
         }
     }
 
-    Ok(())
+    environ.declare_function_names(functions)
 }
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..4c20c89d3f 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::{
+    Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize, option::ArchivedOption,
 };
-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::{
+    FunctionIndex, LocalFunctionIndex, SignatureIndex, TrapInformation, entity::PrimaryMap,
+};
 
 /// 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..5c1d9a14da 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::{
+    Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle, entity::PrimaryMap,
+};
 
 /// 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..19d30c1f03
--- /dev/null
+++ b/lib/compiler/src/types/relocation.rs
@@ -0,0 +1,445 @@
+/*
+ * ! 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::{FunctionIndex, LibCall, LocalFunctionIndex, entity::PrimaryMap};
+
+/// 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,
+
+    /// PC-relative 4-byte
+    PCRel4,
+    /// PC-relative 8-byte
+    PCRel8,
+
+    /// 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,
+
+    // TODO: sort the items when we bump the rkyv version
+    /// absolute 6 bits
+    Abs6Bits,
+    /// absolute 1-byte
+    Abs,
+    /// absolute 2-byte
+    Abs2,
+
+    /// addition at the place of the relocation (1-byte)
+    Add,
+    /// addition at the place of the relocation (2-bytes)
+    Add2,
+    /// addition at the place of the relocation (4-bytes)
+    Add4,
+    /// addition at the place of the relocation (8-bytes)
+    Add8,
+
+    /// subtraction at the place of the relocation (6 bits)
+    Sub6Bits,
+    /// subtraction at the place of the relocation (1-byte)
+    Sub,
+    /// subtraction at the place of the relocation (2-bytes)
+    Sub2,
+    /// subtraction at the place of the relocation (4-bytes)
+    Sub4,
+    /// subtraction at the place of the relocation (8-bytes)
+    Sub8,
+}
+
+impl RelocationKind {
+    pub fn needs_got(&self) -> bool {
+        matches!(
+            self,
+            Self::MachoArm64RelocGotLoadPage21
+                | Self::MachoArm64RelocGotLoadPageoff12
+                | Self::MachoArm64RelocPointerToGot
+                | Self::MachoX86_64RelocGotLoad
+                | Self::MachoX86_64RelocGot
+        )
+    }
+}
+
+/// 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::Abs6Bits
+            | RelocationKind::Abs
+            | RelocationKind::Abs2
+            | RelocationKind::Abs4
+            | 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
+            | RelocationKind::Add
+            | RelocationKind::Add2
+            | RelocationKind::Add4
+            | RelocationKind::Add8
+            | RelocationKind::Sub6Bits
+            | RelocationKind::Sub
+            | RelocationKind::Sub2
+            | RelocationKind::Sub4
+            | RelocationKind::Sub8 => {
+                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::PCRel4 => {
+                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::PCRel8 => {
+                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 relocation to a dynamic trampoline.
+    DynamicTrampoline(FunctionIndex),
+    /// 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 76%
rename from lib/types/src/compilation/symbols.rs
rename to lib/compiler/src/types/symbols.rs
index 239034159c..609de200ff 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::{
+    DeserializeError, FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SerializeError,
+    SignatureIndex,
+    entity::{EntityRef, PrimaryMap},
+};
+
+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,
@@ -60,7 +64,7 @@ pub struct ModuleMetadata {
     pub data_initializers: Box<[OwnedDataInitializer]>,
     /// The function body lengths (used to find function by address)
     pub function_body_lengths: PrimaryMap<LocalFunctionIndex, u64>,
-    /// CPU features used (See [`CpuFeature`](crate::CpuFeature))
+    /// CPU features used (see [`wasmer_types::CpuFeature`])
     pub cpu_features: u64,
 }
 
@@ -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.
@@ -111,8 +111,10 @@ impl ModuleMetadata {
     /// `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)
+        unsafe {
+            let archived = Self::archive_from_slice(metadata_slice)?;
+            Self::deserialize_from_archive(archived)
+        }
     }
 
     /// Deserialize a Module from a slice.
@@ -130,18 +132,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,
-        ))
+        unsafe { Ok(rkyv::access_unchecked(metadata_slice)) }
     }
 
     /// # Safety
@@ -151,15 +142,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 +150,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.lock b/lib/config/Cargo.lock
deleted file mode 100644
index 39ef9fc10b..0000000000
--- a/lib/config/Cargo.lock
+++ /dev/null
@@ -1,511 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
-
-[[package]]
-name = "cc"
-version = "1.0.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "darling"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
-dependencies = [
- "darling_core",
- "darling_macro",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
-dependencies = [
- "darling_core",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "derive_builder"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d67778784b508018359cbc8696edb3db78160bab2c2a28ba7f56ef6932997f8"
-dependencies = [
- "derive_builder_macro",
-]
-
-[[package]]
-name = "derive_builder_core"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c11bdc11a0c47bc7d37d582b5285da6849c96681023680b906673c5707af7b0f"
-dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "derive_builder_macro"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebcda35c7a396850a55ffeac740804b40ffec779b98fffbb1738f4033f0ee79e"
-dependencies = [
- "derive_builder_core",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
-
-[[package]]
-name = "errno"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "half"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
-
-[[package]]
-name = "ident_case"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
-
-[[package]]
-name = "indexmap"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad227c3af19d4914570ad36d30409928b75967c298feb9ea1969db3a610bb14e"
-dependencies = [
- "equivalent",
- "hashbrown",
- "serde",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
-
-[[package]]
-name = "libc"
-version = "0.2.148"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a9bad9f94746442c783ca431b22403b519cd7fbeed0533fdd6328b2f2212128"
-
-[[package]]
-name = "memchr"
-version = "2.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "rustix"
-version = "0.38.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747c788e9ce8e92b12cd485c49ddf90723550b654b32508f979b71a7b1ecda4f"
-dependencies = [
- "bitflags 2.4.0",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
-
-[[package]]
-name = "semver"
-version = "1.0.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_cbor"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
-dependencies = [
- "half",
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.37",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.107"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_spanned"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96426c9936fd7a0124915f9185ea1d20aa9445cc9821142f0a73bc9207a2e186"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_yaml"
-version = "0.9.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a49e178e4452f45cb61d0cd8cebc1b0fafd3e41929e996cef79aa3aca91f574"
-dependencies = [
- "indexmap",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
-dependencies = [
- "cfg-if",
- "fastrand",
- "redox_syscall",
- "rustix",
- "windows-sys",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.49"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.49"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.37",
-]
-
-[[package]]
-name = "toml"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc1433177506450fe920e46a4f9812d0c211f5dd556da10e731a0a3dfa151f0"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.20.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca676d9ba1a322c1b64eb8045a5ec5c0cfb0c9d08e15e9ff622589ad5221c8fe"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa"
-
-[[package]]
-name = "wasmer-toml"
-version = "0.10.0"
-dependencies = [
- "anyhow",
- "derive_builder",
- "indexmap",
- "semver",
- "serde",
- "serde_cbor",
- "serde_json",
- "serde_yaml",
- "tempfile",
- "thiserror",
- "toml",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "winnow"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
-dependencies = [
- "memchr",
-]
diff --git a/lib/config/Cargo.toml b/lib/config/Cargo.toml
index 6475abb967..9502602497 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.700.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"
+derive_builder.workspace = true
+bytesize = { workspace = true, features = ["serde"] }
+schemars = { workspace = true, features = ["url2", "indexmap2"] }
+url = { workspace = true, features = ["serde"] }
+hex.workspace = true
+ciborium.workspace = true
+saffron = { workspace = true, 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..790bae4381
--- /dev/null
+++ b/lib/config/src/app/job.rs
@@ -0,0 +1,395 @@
+use std::{borrow::Cow, fmt::Display, str::FromStr};
+
+use anyhow::anyhow;
+use serde::{Deserialize, Serialize, de::Error};
+
+use indexmap::IndexMap;
+
+use crate::package::PackageSource;
+
+use super::{AppConfigCapabilityMemoryV1, AppVolume, HttpRequest, pretty_duration::PrettyDuration};
+
+/// 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 {
+            match s.parse::<CronExpression>() {
+                Ok(expr) => Ok(Self::Cron(expr)),
+                _ => {
+                    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_id() -> Cow<'static, str> {
+        Cow::Borrowed("JobTrigger")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn schema_name() -> Cow<'static, str> {
+        Self::schema_id()
+    }
+}
+
+#[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::gib(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: 1.0 GiB
+    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..4a07ad628e 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,
-};
+pub use self::{healthcheck::*, http::*, job::*, pretty_duration::*, snapshot_trigger::*, ssh::*};
 
-use std::collections::HashMap;
-
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use bytesize::ByteSize;
+use indexmap::IndexMap;
 
 use crate::package::PackageSource;
 
@@ -25,14 +25,14 @@ pub const HEADER_APP_VERSION_ID: &str = "x-edge-app-version-id";
 
 /// User-facing app.yaml config file for apps.
 ///
-/// NOTE: only used by the backend, Edge itself does not use this format, and
-/// uses [`super::AppVersionV1Spec`] instead.
+/// NOTE: only used by the backend; Edge itself does not use this format and
+/// relies on the internal `AppVersionV1Spec` representation instead.
 #[derive(
     serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
 )]
 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(
@@ -174,8 +177,7 @@ impl AppConfigV1 {
             Self::KIND => {}
             other => {
                 bail!(
-                    "invalid app config: unspported kind '{}', expected {}",
-                    other,
+                    "invalid app config: unspported kind '{other}', expected {}",
                     Self::KIND
                 );
             }
@@ -186,8 +188,8 @@ impl AppConfigV1 {
     }
 }
 
-/// Restricted version of [`super::CapabilityMapV1`], with only a select subset
-/// of settings.
+/// Restricted version of the internal `CapabilityMapV1`, with only a select
+/// subset of settings.
 #[derive(
     serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
 )]
@@ -196,23 +198,29 @@ 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.
 ///
-/// NOTE: this is kept separate from the [`super::CapabilityMemoryV1`] struct
-/// to have separation between the high-level app.yaml and the more internal
-/// App entity.
+/// NOTE: this is kept separate from the internal `CapabilityMemoryV1` struct
+/// to keep the high-level app.yaml distinct from the internal App entity.
 #[derive(
     serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
 )]
@@ -225,6 +233,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 +261,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 +280,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 `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 +362,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 +393,8 @@ scheduled_tasks:
                 }),
                 locality: Some(Locality {
                     regions: vec!["eu-rome".to_string()]
-                })
+                }),
+                jobs: None,
             }
         );
     }
@@ -374,10 +427,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..6133a561d7
--- /dev/null
+++ b/lib/config/src/app/pretty_duration.rs
@@ -0,0 +1,203 @@
+use std::{
+    borrow::Cow,
+    fmt::{Debug, Display},
+    str::FromStr,
+    time::Duration,
+};
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize, de::Error};
+
+#[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() -> Cow<'static, str> {
+        Cow::Borrowed("PrettyDuration")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
+    }
+
+    fn schema_id() -> Cow<'static, str> {
+        Self::schema_name()
+    }
+}
+
+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..635c11e597
--- /dev/null
+++ b/lib/config/src/app/snapshot_trigger.rs
@@ -0,0 +1,125 @@
+use std::{borrow::Cow, fmt::Display, str::FromStr};
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize, de::Error};
+
+#[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() -> Cow<'static, str> {
+        Cow::Borrowed("SnapshotTrigger")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        <String as JsonSchema>::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
+    }
+
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
+    }
+}
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..5e6443d8e4 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,15 +39,15 @@ 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) {
-            let gen =
-                schemars::gen::SchemaGenerator::new(schemars::gen::SchemaSettings::draft2019_09());
+        fn add_schema<T: schemars::JsonSchema>(map: &mut IndexMap<String, String>, name: &str) {
+            let generator =
+                schemars::SchemaGenerator::new(schemars::generate::SchemaSettings::draft2019_09());
             map.insert(
                 format!("{name}.schema.json"),
-                serde_json::to_string_pretty(&gen.into_root_schema_for::<T>()).unwrap(),
+                serde_json::to_string_pretty(&generator.into_root_schema_for::<T>()).unwrap(),
             );
         }
         add_schema::<wasmer_config::app::AppConfigV1>(&mut map, "AppConfigV1");
@@ -63,9 +65,11 @@ mod codegen {
             .unwrap();
 
         let schema_dir = root_dir.join("docs/schema/generated");
-        if !schema_dir.is_dir() {
-            panic!("Expected the {} directory to exist", schema_dir.display());
-        }
+        assert!(
+            schema_dir.is_dir(),
+            "Expected the {} directory to exist",
+            schema_dir.display()
+        );
 
         schema_dir
     }
@@ -83,12 +87,12 @@ mod codegen {
             let path = json_dir.join(filename);
             let contents = std::fs::read_to_string(&path).unwrap();
 
-            if contents != *jsonschema {
-                panic!(
-                    "Auto-generated OpenAPI schema at '{}' is not up to date!\n",
-                    path.display()
-                );
-            }
+            assert_eq!(
+                contents,
+                *jsonschema,
+                "Auto-generated OpenAPI schema at '{}' is not up to date!\n",
+                path.display()
+            );
         }
 
         for res in std::fs::read_dir(&json_dir).unwrap() {
@@ -100,12 +104,11 @@ mod codegen {
                 .expect("non-utf8 filename")
                 .to_string();
 
-            if !jsonschema.contains_key(&file_name) {
-                panic!(
-                    "Found unexpected file in the json schemas directory: '{}' - delete it!",
-                    entry.path().display(),
-                );
-            }
+            assert!(
+                jsonschema.contains_key(&file_name),
+                "Found unexpected file in the json schemas directory: '{}' - delete it!",
+                entry.path().display()
+            );
         }
     }
 }
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/hash.rs b/lib/config/src/hash.rs
index 880edf0d07..123baef33e 100644
--- a/lib/config/src/hash.rs
+++ b/lib/config/src/hash.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 /// Sha256 hash, represented as bytes.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Sha256Hash(pub [u8; 32]);
@@ -46,12 +48,20 @@ impl std::fmt::Display for Sha256Hash {
 }
 
 impl schemars::JsonSchema for Sha256Hash {
-    fn schema_name() -> String {
-        "Sha256Hash".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("Sha256Hash")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
diff --git a/lib/config/src/package/mod.rs b/lib/config/src/package/mod.rs
index 9f3ce2e743..cec1de476a 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,
@@ -30,7 +30,7 @@ use std::{
 
 use indexmap::IndexMap;
 use semver::{Version, VersionReq};
-use serde::{de::Error as _, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::Error as _};
 use thiserror::Error;
 
 /// The ABI is a hint to WebAssembly runtimes about what additional imports to
@@ -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)
@@ -833,15 +862,14 @@ impl Manifest {
             }
         }
 
-        if let Some(package) = &self.package {
-            if let Some(entrypoint) = package.entrypoint.as_deref() {
-                if !commands.contains_key(entrypoint) {
-                    return Err(ValidationError::InvalidEntrypoint {
-                        entrypoint: entrypoint.to_string(),
-                        available_commands: commands.keys().map(ToString::to_string).collect(),
-                    });
-                }
-            }
+        if let Some(package) = &self.package
+            && let Some(entrypoint) = package.entrypoint.as_deref()
+            && !commands.contains_key(entrypoint)
+        {
+            return Err(ValidationError::InvalidEntrypoint {
+                entrypoint: entrypoint.to_string(),
+                available_commands: commands.keys().map(ToString::to_string).collect(),
+            });
         }
 
         Ok(())
@@ -901,7 +929,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 +966,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}\"")]
@@ -946,7 +974,9 @@ pub enum ValidationError {
         command: String,
         module: ModuleReference,
     },
-    #[error("The \"{command}\" command refers to a nonexistent dependency, \"{dependency}\" in \"{module_ref}\"")]
+    #[error(
+        "The \"{command}\" command refers to a nonexistent dependency, \"{dependency}\" in \"{module_ref}\""
+    )]
     MissingDependency {
         command: String,
         dependency: String,
@@ -967,7 +997,7 @@ pub enum ValidationError {
 mod tests {
     use std::fmt::Debug;
 
-    use serde::{de::DeserializeOwned, Deserialize};
+    use serde::{Deserialize, de::DeserializeOwned};
     use toml::toml;
 
     use super::*;
@@ -990,7 +1020,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 +1028,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 +1053,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 +1076,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 +1084,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..199cfb0f7f 100644
--- a/lib/config/src/package/named_package_ident.rs
+++ b/lib/config/src/package/named_package_ident.rs
@@ -1,4 +1,4 @@
-use std::{fmt::Write, str::FromStr};
+use std::{borrow::Cow, fmt::Write, str::FromStr};
 
 use semver::VersionReq;
 
@@ -55,7 +55,8 @@ impl std::str::FromStr for Tag {
 /// Parsed representation of a package identifier.
 ///
 /// Format:
-/// [https?://<domain>/][namespace/]name[@version]
+/// `https?://<domain>/namespace/name@version`
+/// where the registry, namespace, and version components are optional.
 #[derive(PartialEq, Eq, Clone, Debug, Hash)]
 pub struct NamedPackageIdent {
     pub registry: Option<String>,
@@ -121,7 +122,7 @@ impl NamedPackageIdent {
         };
 
         let reg = if !reg.starts_with("http://") && !reg.starts_with("https://") {
-            format!("https://{}", reg)
+            format!("https://{reg}")
         } else {
             reg.clone()
         };
@@ -133,7 +134,8 @@ impl NamedPackageIdent {
 
     /// Build the ident for a package.
     ///
-    /// Format: [NAMESPACE/]NAME[@tag]
+    /// Format: `NAMESPACE/NAME@tag`
+    /// where the namespace and tag components are optional.
     pub fn build_identifier(&self) -> String {
         let mut ident = if let Some(ns) = &self.namespace {
             format!("{}/{}", ns, self.name)
@@ -144,7 +146,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 +155,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 +169,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 {
@@ -280,12 +300,20 @@ impl<'de> serde::Deserialize<'de> for NamedPackageIdent {
 }
 
 impl schemars::JsonSchema for NamedPackageIdent {
-    fn schema_name() -> String {
-        "NamedPackageIdent".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("NamedPackageIdent")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_id() -> Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
@@ -443,4 +471,31 @@ 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..758b3ca68b 100644
--- a/lib/config/src/package/package_hash.rs
+++ b/lib/config/src/package/package_hash.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::{hash::Sha256Hash, package::PackageParseError};
 
 /// Hash for a package.
@@ -32,7 +34,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}"),
         }
     }
 }
@@ -75,12 +77,20 @@ impl<'de> serde::Deserialize<'de> for PackageHash {
 }
 
 impl schemars::JsonSchema for PackageHash {
-    fn schema_name() -> String {
-        "PackageHash".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("PackageHash")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
diff --git a/lib/config/src/package/package_id.rs b/lib/config/src/package/package_id.rs
index 2a292a6774..755a03b83a 100644
--- a/lib/config/src/package/package_id.rs
+++ b/lib/config/src/package/package_id.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use super::PackageHash;
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -77,11 +79,19 @@ impl std::fmt::Display for PackageId {
 }
 
 impl schemars::JsonSchema for PackageId {
-    fn schema_name() -> String {
-        "PackageIdent".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("PackageIdent")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
     }
 }
diff --git a/lib/config/src/package/package_ident.rs b/lib/config/src/package/package_ident.rs
index 5b03d6ef81..6f8d744e5e 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 std::{borrow::Cow, 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 {
@@ -44,13 +55,14 @@ impl std::str::FromStr for PackageIdent {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Ok(hash) = PackageHash::from_str(s) {
             Ok(Self::Hash(hash))
-        } else if let Ok(named) = NamedPackageIdent::from_str(s) {
-            Ok(Self::Named(named))
         } else {
-            Err(PackageParseError::new(
-                s,
-                "invalid package ident: expected a hash or a valid named package identifier",
-            ))
+            match NamedPackageIdent::from_str(s) {
+                Ok(named) => Ok(Self::Named(named)),
+                _ => Err(PackageParseError::new(
+                    s,
+                    "invalid package ident: expected a hash or a valid named package identifier",
+                )),
+            }
         }
     }
 }
@@ -84,11 +96,45 @@ impl<'de> serde::Deserialize<'de> for PackageIdent {
 }
 
 impl schemars::JsonSchema for PackageIdent {
-    fn schema_name() -> String {
-        "PackageIdent".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("PackageIdent")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
+    }
+}
+
+#[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/config/src/package/package_source.rs b/lib/config/src/package/package_source.rs
index e01d5b2fda..1fd5d06b0b 100644
--- a/lib/config/src/package/package_source.rs
+++ b/lib/config/src/package/package_source.rs
@@ -1,4 +1,4 @@
-use std::str::FromStr;
+use std::{borrow::Cow, str::FromStr};
 
 use super::{
     NamedPackageId, NamedPackageIdent, PackageHash, PackageId, PackageIdent, PackageParseError,
@@ -7,7 +7,7 @@ use super::{
 /// Source location of a package.
 #[derive(PartialEq, Eq, Clone, Debug, Hash)]
 pub enum PackageSource {
-    /// An identifier in the format prescribed by [`WebcIdent`].
+    /// An identifier in the format prescribed by the `WebcIdent` type.
     Ident(PackageIdent),
     /// An absolute or relative (dot-leading) path.
     Path(String),
@@ -146,12 +146,20 @@ impl<'de> serde::Deserialize<'de> for PackageSource {
 }
 
 impl schemars::JsonSchema for PackageSource {
-    fn schema_name() -> String {
-        "PackageSource".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("PackageSource")
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
+    }
+
+    fn inline_schema() -> bool {
+        false
+    }
+
+    fn schema_id() -> std::borrow::Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
diff --git a/lib/derive/Cargo.toml b/lib/derive/Cargo.toml
index 7576910511..5e22ced704 100644
--- a/lib/derive/Cargo.toml
+++ b/lib/derive/Cargo.toml
@@ -13,11 +13,13 @@ version.workspace = true
 proc-macro = true
 
 [dependencies]
-syn = { version = "1.0.72", features = ["full", "extra-traits"] }
-quote = "1"
-proc-macro2 = "1"
-proc-macro-error = "1.0.0"
+syn = { workspace = true, features = ["full", "extra-traits", "derive", "parsing", "proc-macro", "printing"] }
+quote.workspace = true
+proc-macro2.workspace = true
+proc-macro-error2.workspace = true
 
 [dev-dependencies]
-wasmer-types = { path = "../types", default-features=false, features = ["std"] }
-compiletest_rs = "0.6"
+wasmer-types = { path = "../types", default-features = false, features = [
+	"std",
+] }
+compiletest_rs.workspace = true
diff --git a/lib/derive/src/lib.rs b/lib/derive/src/lib.rs
index fe781efff8..8137fc2b6d 100644
--- a/lib/derive/src/lib.rs
+++ b/lib/derive/src/lib.rs
@@ -1,7 +1,7 @@
 extern crate proc_macro;
 
-use proc_macro_error::proc_macro_error;
-use syn::{parse_macro_input, DeriveInput};
+use proc_macro_error2::proc_macro_error;
+use syn::{DeriveInput, parse_macro_input};
 
 mod value_type;
 
@@ -9,6 +9,6 @@ mod value_type;
 #[proc_macro_derive(ValueType)]
 pub fn derive_value_type(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    let gen = value_type::impl_value_type(&input);
-    gen.into()
+    let r#gen = value_type::impl_value_type(&input);
+    r#gen.into()
 }
diff --git a/lib/derive/src/value_type.rs b/lib/derive/src/value_type.rs
index 3ba535e5d3..be66a9cad3 100644
--- a/lib/derive/src/value_type.rs
+++ b/lib/derive/src/value_type.rs
@@ -1,31 +1,23 @@
+use proc_macro_error2::abort;
 use proc_macro2::TokenStream;
-use proc_macro_error::abort;
 use quote::quote;
-use syn::{Data, DeriveInput, Fields, Member, Meta, MetaList, NestedMeta};
+use syn::{Data, DeriveInput, Fields, Member};
 
 /// We can only validate types that have a well defined layout.
 fn check_repr(input: &DeriveInput) {
-    let reprs = input
-        .attrs
-        .iter()
-        .filter_map(|attr| {
-            if let Meta::List(MetaList { path, nested, .. }) = attr.parse_meta().unwrap() {
-                if path.is_ident("repr") {
-                    return Some(nested.into_iter().collect::<Vec<_>>());
+    if input.attrs.iter().any(|attr| {
+        attr.path().is_ident("repr") && {
+            let mut valid = false;
+            let _ = attr.parse_nested_meta(|meta| {
+                if meta.path.is_ident("C") || meta.path.is_ident("transparent") {
+                    valid = true;
                 }
-            }
-            None
-        })
-        .flatten();
-
-    // We require either repr(C) or repr(transparent) to ensure fields are in
-    // source code order.
-    for meta in reprs {
-        if let NestedMeta::Meta(Meta::Path(path)) = meta {
-            if path.is_ident("C") || path.is_ident("transparent") {
-                return;
-            }
+                Ok(())
+            });
+            valid
         }
+    }) {
+        return;
     }
 
     abort!(
diff --git a/lib/derive/tests/compiletest.rs b/lib/derive/tests/compiletest.rs
index 7cda93820a..acdfe77fd2 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()
     };
 
@@ -44,7 +44,7 @@ fn run_mode(src: &'static str, mode: &'static str) {
 
 #[test]
 #[ignore] // ignored by default because it needs to essentially run `cargo clean` to work correctly
-          // and that's really, really slow
+// and that's really, really slow
 fn compile_test() {
     run_mode("compile-fail", "compile-fail");
 }
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..d4a201d257 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.700.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 = "=7.0.0" }
+wasmer-config = { default-features = false, path = "../config", version = "=0.700.0" }
+wasmer-wasix-types = { path = "../wasi-types", version = "0.700.0", features = [
+	"enable-serde",
+] }
+virtual-net = { path = "../virtual-net", version = "0.700.0", default-features = false, features = [
+	"rkyv",
+] }
+virtual-fs = { path = "../virtual-fs", version = "0.700.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"
-bincode = { version = "1.3" }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
-anyhow = "1.0"
-rkyv = { workspace = true }
-bytecheck = { version = "0.6.8" }
-lz4_flex = { version = "0.11" }
-num_enum = "0.5.7"
-serde_json = { version = "^1" }
+base64.workspace = true
+derive_more.workspace = true
+rkyv.workspace = true
+
+thiserror.workspace = true
+bytes.workspace = true
+async-trait.workspace = true
+tracing.workspace = true
+bincode.workspace = true
+serde = { workspace = true, default-features = false, features = ["derive"] }
+serde_json.workspace = true
+anyhow.workspace = true
+bytecheck.workspace = true
+lz4_flex.workspace = true
+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..6c2143626b 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},
+    Archive, Archived,
+    rancor::Fallible,
+    ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived, Serialize,
 };
 
 #[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..f1a371ff96 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},
+    Archive, Archived,
+    rancor::Fallible,
+    ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived, Serialize,
 };
 
 /// 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..1a0e6331cb 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::{
+    Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize, api::serialize_using,
+};
 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,223 @@ 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(unsafe { rkyv::access_unchecked(data) })
+            }
             JournalEntryRecordType::ClearEtherealV1 => {
-                ArchivedJournalEntry::ClearEtherealV1(rkyv::archived_root::<
-                    JournalEntryClearEtherealV1,
-                >(data))
+                ArchivedJournalEntry::ClearEtherealV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::ProcessExitV1 => {
+                ArchivedJournalEntry::ProcessExitV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SetThreadV1 => {
+                ArchivedJournalEntry::SetThreadV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::CloseThreadV1 => {
+                ArchivedJournalEntry::CloseThreadV1(unsafe { 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(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::FileDescriptorWriteV1 => {
-                ArchivedJournalEntry::FileDescriptorWriteV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorWriteV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorWriteV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::UpdateMemoryRegionV1 => {
-                ArchivedJournalEntry::UpdateMemoryRegionV1(rkyv::archived_root::<
-                    JournalEntryUpdateMemoryRegionV1,
-                >(data))
+                ArchivedJournalEntry::UpdateMemoryRegionV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SetClockTimeV1 => {
-                ArchivedJournalEntry::SetClockTimeV1(rkyv::archived_root::<
-                    JournalEntrySetClockTimeV1,
-                >(data))
+                ArchivedJournalEntry::SetClockTimeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::OpenFileDescriptorV1 => {
-                ArchivedJournalEntry::OpenFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryOpenFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::OpenFileDescriptorV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::OpenFileDescriptorV2 => {
+                ArchivedJournalEntry::OpenFileDescriptorV2(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CloseFileDescriptorV1 => {
-                ArchivedJournalEntry::CloseFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryCloseFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::CloseFileDescriptorV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::RenumberFileDescriptorV1 => {
-                ArchivedJournalEntry::RenumberFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryRenumberFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::RenumberFileDescriptorV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::DuplicateFileDescriptorV1 => {
-                ArchivedJournalEntry::DuplicateFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryDuplicateFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::DuplicateFileDescriptorV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
+            }
+            JournalEntryRecordType::DuplicateFileDescriptorV2 => {
+                ArchivedJournalEntry::DuplicateFileDescriptorV2(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::CreateDirectoryV1 => {
-                ArchivedJournalEntry::CreateDirectoryV1(rkyv::archived_root::<
-                    JournalEntryCreateDirectoryV1,
-                >(data))
+                ArchivedJournalEntry::CreateDirectoryV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::RemoveDirectoryV1 => {
-                ArchivedJournalEntry::RemoveDirectoryV1(rkyv::archived_root::<
-                    JournalEntryRemoveDirectoryV1,
-                >(data))
+                ArchivedJournalEntry::RemoveDirectoryV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PathSetTimesV1 => {
-                ArchivedJournalEntry::PathSetTimesV1(rkyv::archived_root::<
-                    JournalEntryPathSetTimesV1,
-                >(data))
+                ArchivedJournalEntry::PathSetTimesV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::FileDescriptorSetTimesV1 => {
-                ArchivedJournalEntry::FileDescriptorSetTimesV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetTimesV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetTimesV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetSizeV1 => {
-                ArchivedJournalEntry::FileDescriptorSetSizeV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetSizeV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetSizeV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
+            }
+            JournalEntryRecordType::FileDescriptorSetFdFlagsV1 => {
+                ArchivedJournalEntry::FileDescriptorSetFdFlagsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetFlagsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetFlagsV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetFlagsV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetFlagsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetRightsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetRightsV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetRightsV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetRightsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorAdviseV1 => {
-                ArchivedJournalEntry::FileDescriptorAdviseV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorAdviseV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorAdviseV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorAllocateV1 => {
-                ArchivedJournalEntry::FileDescriptorAllocateV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorAllocateV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorAllocateV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::CreateHardLinkV1 => {
-                ArchivedJournalEntry::CreateHardLinkV1(rkyv::archived_root::<
-                    JournalEntryCreateHardLinkV1,
-                >(data))
+                ArchivedJournalEntry::CreateHardLinkV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CreateSymbolicLinkV1 => {
-                ArchivedJournalEntry::CreateSymbolicLinkV1(rkyv::archived_root::<
-                    JournalEntryCreateSymbolicLinkV1,
-                >(data))
+                ArchivedJournalEntry::CreateSymbolicLinkV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::UnlinkFileV1 => {
+                ArchivedJournalEntry::UnlinkFileV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::PathRenameV1 => {
+                ArchivedJournalEntry::PathRenameV1(unsafe { 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(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::EpollCreateV1 => {
+                ArchivedJournalEntry::EpollCreateV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::EpollCtlV1 => {
+                ArchivedJournalEntry::EpollCtlV1(unsafe { 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(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::CreatePipeV1 => {
+                ArchivedJournalEntry::CreatePipeV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::CreateEventV1 => {
+                ArchivedJournalEntry::CreateEventV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::PortAddAddrV1 => {
+                ArchivedJournalEntry::PortAddAddrV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::PortDelAddrV1 => {
+                ArchivedJournalEntry::PortDelAddrV1(unsafe { 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(unsafe { rkyv::access_unchecked(data) })
+            }
             JournalEntryRecordType::PortUnbridgeV1 => return Ok(JournalEntry::PortUnbridgeV1),
             JournalEntryRecordType::PortDhcpAcquireV1 => {
-                return Ok(JournalEntry::PortDhcpAcquireV1)
+                return Ok(JournalEntry::PortDhcpAcquireV1);
             }
             JournalEntryRecordType::PortGatewaySetV1 => {
-                ArchivedJournalEntry::PortGatewaySetV1(rkyv::archived_root::<
-                    JournalEntryPortGatewaySetV1,
-                >(data))
+                ArchivedJournalEntry::PortGatewaySetV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortRouteAddV1 => {
-                ArchivedJournalEntry::PortRouteAddV1(rkyv::archived_root::<
-                    JournalEntryPortRouteAddV1,
-                >(data))
+                ArchivedJournalEntry::PortRouteAddV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortRouteClearV1 => return Ok(JournalEntry::PortRouteClearV1),
             JournalEntryRecordType::PortRouteDelV1 => {
-                ArchivedJournalEntry::PortRouteDelV1(rkyv::archived_root::<
-                    JournalEntryPortRouteDelV1,
-                >(data))
+                ArchivedJournalEntry::PortRouteDelV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SocketOpenV1 => {
+                ArchivedJournalEntry::SocketOpenV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SocketPairV1 => {
+                ArchivedJournalEntry::SocketPairV1(unsafe { rkyv::access_unchecked(data) })
             }
-            JournalEntryRecordType::SocketOpenV1 => ArchivedJournalEntry::SocketOpenV1(
-                rkyv::archived_root::<JournalEntrySocketOpenV1>(data),
-            ),
             JournalEntryRecordType::SocketListenV1 => {
-                ArchivedJournalEntry::SocketListenV1(rkyv::archived_root::<
-                    JournalEntrySocketListenV1,
-                >(data))
+                ArchivedJournalEntry::SocketListenV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SocketBindV1 => {
+                ArchivedJournalEntry::SocketBindV1(unsafe { rkyv::access_unchecked(data) })
             }
-            JournalEntryRecordType::SocketBindV1 => ArchivedJournalEntry::SocketBindV1(
-                rkyv::archived_root::<JournalEntrySocketBindV1>(data),
-            ),
             JournalEntryRecordType::SocketConnectedV1 => {
-                ArchivedJournalEntry::SocketConnectedV1(rkyv::archived_root::<
-                    JournalEntrySocketConnectedV1,
-                >(data))
+                ArchivedJournalEntry::SocketConnectedV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketAcceptedV1 => {
-                ArchivedJournalEntry::SocketAcceptedV1(rkyv::archived_root::<
-                    JournalEntrySocketAcceptedV1,
-                >(data))
+                ArchivedJournalEntry::SocketAcceptedV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketJoinIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketJoinIpv4MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketJoinIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketJoinIpv6MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketLeaveIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketLeaveIpv4MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketLeaveIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketLeaveIpv6MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketSendFileV1 => {
-                ArchivedJournalEntry::SocketSendFileV1(rkyv::archived_root::<
-                    JournalEntrySocketSendFileV1,
-                >(data))
+                ArchivedJournalEntry::SocketSendFileV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSendToV1 => {
-                ArchivedJournalEntry::SocketSendToV1(rkyv::archived_root::<
-                    JournalEntrySocketSendToV1,
-                >(data))
+                ArchivedJournalEntry::SocketSendToV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SocketSendV1 => {
+                ArchivedJournalEntry::SocketSendV1(unsafe { rkyv::access_unchecked(data) })
             }
-            JournalEntryRecordType::SocketSendV1 => ArchivedJournalEntry::SocketSendV1(
-                rkyv::archived_root::<JournalEntrySocketSendV1>(data),
-            ),
             JournalEntryRecordType::SocketSetOptFlagV1 => {
-                ArchivedJournalEntry::SocketSetOptFlagV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptFlagV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptFlagV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSetOptSizeV1 => {
-                ArchivedJournalEntry::SocketSetOptSizeV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptSizeV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptSizeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSetOptTimeV1 => {
-                ArchivedJournalEntry::SocketSetOptTimeV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptTimeV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptTimeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketShutdownV1 => {
-                ArchivedJournalEntry::SocketShutdownV1(rkyv::archived_root::<
-                    JournalEntrySocketShutdownV1,
-                >(data))
+                ArchivedJournalEntry::SocketShutdownV1(unsafe { rkyv::access_unchecked(data) })
+            }
+            JournalEntryRecordType::SnapshotV1 => {
+                ArchivedJournalEntry::SnapshotV1(unsafe { 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 +330,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 +381,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 +409,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 +448,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 +508,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 +592,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 +747,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,122 +844,151 @@ 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))?;
+        .map_err(|err| anyhow::format_err!("failed to serialize journal record - {err}"))?;
         Ok(amt)
     }
 }
@@ -877,7 +1000,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 +1017,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 +1053,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 +1075,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 +1083,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 +1097,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 +1111,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 +1120,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 +1135,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 +1147,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 +1157,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 +1166,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 +1181,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 +1205,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 +1214,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 +1223,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 +1242,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 +1251,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 +1264,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 +1275,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 +1284,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 +1302,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 +1312,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 +1323,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 +1333,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 +1345,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 +1355,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 +1364,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 +1375,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 +1383,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 +1391,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 +1402,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 +1419,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 +1438,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 +1446,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 +1454,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 +1464,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 +1472,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 +1483,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 +1491,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 +1499,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 +1519,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 +1528,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 +1538,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 +1551,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 +1561,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 +1571,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 +1581,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 +1591,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 +1602,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 +1614,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 +1625,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 +1635,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 +1645,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 +1655,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 +1664,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 +1672,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 +1683,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 +1693,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 +1707,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 +1715,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 +1735,7 @@ pub enum JournalExitCodeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSnapshotTriggerV1 {
     Idle,
     Listen,
@@ -1579,6 +1749,7 @@ pub enum JournalSnapshotTriggerV1 {
     NonDeterministicCall,
     Bootstrap,
     Transaction,
+    Explicit,
 }
 
 #[repr(C)]
@@ -1595,7 +1766,7 @@ pub enum JournalSnapshotTriggerV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalEpollCtlV1 {
     Add,
     Mod,
@@ -1606,7 +1777,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 +1800,7 @@ pub struct JournalEpollEventCtlV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalStreamSecurityV1 {
     Unencrypted,
     AnyEncryption,
@@ -1652,7 +1823,7 @@ pub enum JournalStreamSecurityV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalAddressfamilyV1 {
     Unspec,
     Inet4,
@@ -1674,7 +1845,7 @@ pub enum JournalAddressfamilyV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSocktypeV1 {
     Unknown,
     Stream,
@@ -1697,7 +1868,7 @@ pub enum JournalSocktypeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSockoptionV1 {
     Noop,
     ReusePort,
@@ -1742,7 +1913,7 @@ pub enum JournalSockoptionV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalTimeTypeV1 {
     ReadTimeout,
     WriteTimeout,
@@ -1766,7 +1937,7 @@ pub enum JournalTimeTypeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSocketShutdownV1 {
     Read,
     Write,
@@ -1788,7 +1959,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 +1968,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..c33edb3755 100644
--- a/lib/journal/src/concrete/archived_from.rs
+++ b/lib/journal/src/concrete/archived_from.rs
@@ -13,6 +13,7 @@ impl From<wasi::Snapshot0Clockid> for JournalSnapshot0ClockidV1 {
             wasi::Snapshot0Clockid::ProcessCputimeId => JournalSnapshot0ClockidV1::ProcessCputimeId,
             wasi::Snapshot0Clockid::ThreadCputimeId => JournalSnapshot0ClockidV1::ThreadCputimeId,
             wasi::Snapshot0Clockid::Unknown => JournalSnapshot0ClockidV1::Unknown,
+            _ => panic!("Unsupported Snapshot0Clockid variant"),
         }
     }
 }
@@ -52,6 +53,7 @@ impl From<wasi::Whence> for JournalWhenceV1 {
             wasi::Whence::Cur => JournalWhenceV1::Cur,
             wasi::Whence::End => JournalWhenceV1::End,
             wasi::Whence::Unknown => JournalWhenceV1::Unknown,
+            _ => panic!("Unsupported Whence variant"),
         }
     }
 }
@@ -88,6 +90,7 @@ impl From<wasi::Advice> for JournalAdviceV1 {
             wasi::Advice::Dontneed => JournalAdviceV1::Dontneed,
             wasi::Advice::Noreuse => JournalAdviceV1::Noreuse,
             wasi::Advice::Unknown => JournalAdviceV1::Unknown,
+            _ => panic!("Unsupported Advice variant"),
         }
     }
 }
@@ -140,20 +143,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 +159,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 +181,7 @@ impl From<SnapshotTrigger> for JournalSnapshotTriggerV1 {
             SnapshotTrigger::NonDeterministicCall => JournalSnapshotTriggerV1::NonDeterministicCall,
             SnapshotTrigger::Bootstrap => JournalSnapshotTriggerV1::Bootstrap,
             SnapshotTrigger::Transaction => JournalSnapshotTriggerV1::Transaction,
+            SnapshotTrigger::Explicit => JournalSnapshotTriggerV1::Explicit,
         }
     }
 }
@@ -204,6 +201,7 @@ impl From<JournalSnapshotTriggerV1> for SnapshotTrigger {
             JournalSnapshotTriggerV1::NonDeterministicCall => SnapshotTrigger::NonDeterministicCall,
             JournalSnapshotTriggerV1::Bootstrap => SnapshotTrigger::Bootstrap,
             JournalSnapshotTriggerV1::Transaction => SnapshotTrigger::Transaction,
+            JournalSnapshotTriggerV1::Explicit => SnapshotTrigger::Explicit,
         }
     }
 }
@@ -225,6 +223,7 @@ impl From<&'_ ArchivedJournalSnapshotTriggerV1> for SnapshotTrigger {
             }
             ArchivedJournalSnapshotTriggerV1::Bootstrap => SnapshotTrigger::Bootstrap,
             ArchivedJournalSnapshotTriggerV1::Transaction => SnapshotTrigger::Transaction,
+            ArchivedJournalSnapshotTriggerV1::Explicit => SnapshotTrigger::Explicit,
         }
     }
 }
@@ -289,11 +288,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(),
         }
     }
 }
@@ -343,6 +342,7 @@ impl From<wasi::Addressfamily> for JournalAddressfamilyV1 {
             wasi::Addressfamily::Inet4 => JournalAddressfamilyV1::Inet4,
             wasi::Addressfamily::Inet6 => JournalAddressfamilyV1::Inet6,
             wasi::Addressfamily::Unix => JournalAddressfamilyV1::Unix,
+            _ => panic!("Unsupported Addressfamily variant"),
         }
     }
 }
@@ -377,6 +377,7 @@ impl From<wasi::Socktype> for JournalSocktypeV1 {
             wasi::Socktype::Raw => JournalSocktypeV1::Raw,
             wasi::Socktype::Seqpacket => JournalSocktypeV1::Seqpacket,
             wasi::Socktype::Unknown => JournalSocktypeV1::Unknown,
+            _ => panic!("Unsupported Socktype variant"),
         }
     }
 }
@@ -435,6 +436,7 @@ impl From<wasi::Sockoption> for JournalSockoptionV1 {
             wasi::Sockoption::MulticastTtlV4 => JournalSockoptionV1::MulticastTtlV4,
             wasi::Sockoption::Type => JournalSockoptionV1::Type,
             wasi::Sockoption::Proto => JournalSockoptionV1::Proto,
+            _ => panic!("Unsupported Sockoption variant"),
         }
     }
 }
@@ -593,7 +595,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 +620,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 +628,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 +668,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 +685,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 +697,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,19 +709,15 @@ 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(
-                ArchivedJournalEntryFileDescriptorSeekV1 {
-                    fd,
-                    offset,
-                    ref whence,
-                },
+                ArchivedJournalEntryFileDescriptorSeekV1 { fd, offset, whence },
             ) => Self::FileDescriptorSeekV1 {
-                fd: *fd,
-                offset: *offset,
+                fd: fd.to_native(),
+                offset: offset.to_native(),
                 whence: whence.into(),
             },
             ArchivedJournalEntry::OpenFileDescriptorV1(
@@ -732,28 +732,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),
-                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()),
+            },
+            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.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,32 +790,32 @@ 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 {
                 since_epoch,
-                ref trigger,
+                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(),
             },
             ArchivedJournalEntry::SetClockTimeV1(ArchivedJournalEntrySetClockTimeV1 {
-                ref clock_id,
+                clock_id,
                 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 +823,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 +852,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 +867,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,29 +897,31 @@ 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 {
                     fd,
                     offset,
                     len,
-                    ref advice,
+                    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 +930,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 +944,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,17 +953,17 @@ 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,
-                ref op,
+                op,
                 fd,
-                ref event,
+                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 +979,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 +991,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 {
@@ -969,7 +1016,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             ArchivedJournalEntry::PortBridgeV1(ArchivedJournalEntryPortBridgeV1 {
                 network,
                 token,
-                ref security,
+                security,
             }) => Self::PortBridgeV1 {
                 network: String::from_utf8_lossy(network.as_ref()),
                 token: String::from_utf8_lossy(token.as_ref()),
@@ -992,36 +1039,40 @@ 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 }) => {
                 Self::PortRouteDelV1 { ip: ip.as_ipaddr() }
             }
             ArchivedJournalEntry::SocketOpenV1(ArchivedJournalEntrySocketOpenV1 {
-                ref af,
-                ref ty,
+                af,
+                ty,
                 pt,
                 fd,
             }) => 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 +1081,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 +1093,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 +1107,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 +1118,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 +1129,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 +1140,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 +1150,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 +1162,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,43 +1174,43 @@ 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 {
                 fd,
-                ref opt,
+                opt,
                 flag,
             }) => Self::SocketSetOptFlagV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 opt: opt.into(),
                 flag: *flag,
             },
             ArchivedJournalEntry::SocketSetOptSizeV1(ArchivedJournalEntrySocketSetOptSizeV1 {
                 fd,
-                ref opt,
+                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,
+                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,
+                how,
             }) => Self::SocketShutdownV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 how: how.into(),
             },
             ArchivedJournalEntry::CreateEventV1(ArchivedJournalEntryCreateEventV1 {
@@ -1167,9 +1218,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/compacting_log_file.rs b/lib/journal/src/concrete/compacting_log_file.rs
index 9efba2b603..a9bbfce27b 100644
--- a/lib/journal/src/concrete/compacting_log_file.rs
+++ b/lib/journal/src/concrete/compacting_log_file.rs
@@ -180,10 +180,8 @@ impl CompactingLogFileJournalTx {
 impl Drop for CompactingLogFileJournalTx {
     fn drop(&mut self) {
         let triggered = self.state.lock().unwrap().on_drop;
-        if triggered {
-            if let Err(err) = self.compact_now() {
-                tracing::error!("failed to compact log - {}", err);
-            }
+        if triggered && let Err(err) = self.compact_now() {
+            tracing::error!("failed to compact log - {}", err);
         }
     }
 }
@@ -210,15 +208,15 @@ impl WritableJournal for CompactingLogFileJournalTx {
             }
 
             let mut triggered = false;
-            if let Some(on) = state.on_n_records.as_ref() {
-                if state.cnt_records >= *on {
-                    triggered = true;
-                }
+            if let Some(on) = state.on_n_records.as_ref()
+                && state.cnt_records >= *on
+            {
+                triggered = true;
             }
-            if let Some(on) = state.on_n_size.as_ref() {
-                if state.cnt_size >= *on {
-                    triggered = true;
-                }
+            if let Some(on) = state.on_n_size.as_ref()
+                && state.cnt_size >= *on
+            {
+                triggered = true;
             }
 
             if let Some(factor) = state.on_factor_size.as_ref() {
diff --git a/lib/journal/src/concrete/counting.rs b/lib/journal/src/concrete/counting.rs
index d78fe7029f..e061b0aebe 100644
--- a/lib/journal/src/concrete/counting.rs
+++ b/lib/journal/src/concrete/counting.rs
@@ -1,6 +1,6 @@
 use std::sync::{
-    atomic::{AtomicU64, AtomicUsize, Ordering},
     Arc,
+    atomic::{AtomicU64, AtomicUsize, Ordering},
 };
 
 use super::*;
diff --git a/lib/journal/src/concrete/filter.rs b/lib/journal/src/concrete/filter.rs
index c6412be1e7..918554df20 100644
--- a/lib/journal/src/concrete/filter.rs
+++ b/lib/journal/src/concrete/filter.rs
@@ -226,13 +226,13 @@ impl<W: WritableJournal, R: ReadableJournal> FilteredJournal<W, R> {
 impl<W: WritableJournal> WritableJournal for FilteredJournalTx<W> {
     fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
         let event_index = self.config.event_index.fetch_add(1, Ordering::SeqCst);
-        if let Some(events) = self.config.filter_events.as_ref() {
-            if !events.contains(&event_index) {
-                return Ok(LogWriteResult {
-                    record_start: 0,
-                    record_end: 0,
-                });
-            }
+        if let Some(events) = self.config.filter_events.as_ref()
+            && !events.contains(&event_index)
+        {
+            return Ok(LogWriteResult {
+                record_start: 0,
+                record_end: 0,
+            });
         }
 
         let evt = match entry {
@@ -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..7ff96e54c7 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::{
+        Positional, Serializer, Writer,
+        allocator::{Arena, ArenaHandle},
+        sharing::Share,
+        writer::IoWriter,
+    },
 };
 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();
@@ -75,9 +120,7 @@ impl LogFileJournalTx {
             let magic = u64::from_be_bytes(buffer_ptr[0..8].try_into().unwrap());
             if magic != JOURNAL_MAGIC_NUMBER {
                 return Err(anyhow::format_err!(
-                    "invalid magic number of journal ({} vs {})",
-                    magic,
-                    JOURNAL_MAGIC_NUMBER
+                    "invalid magic number of journal ({magic} vs {JOURNAL_MAGIC_NUMBER})"
                 ));
             }
             buffer_ptr.advance(8);
@@ -101,6 +144,7 @@ impl LogFileJournal {
             .read(true)
             .write(true)
             .create(true)
+            .truncate(false)
             .open(path)?;
         Self::from_file(file)
     }
@@ -123,24 +167,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 +232,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 +272,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 +410,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 +427,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -375,7 +443,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 +463,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -415,8 +490,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 +500,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 +520,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -472,7 +554,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 +574,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -503,8 +592,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/pipe.rs b/lib/journal/src/concrete/pipe.rs
index fa0dfaf3f8..14807f35da 100644
--- a/lib/journal/src/concrete/pipe.rs
+++ b/lib/journal/src/concrete/pipe.rs
@@ -1,6 +1,6 @@
-use std::sync::mpsc::TryRecvError;
 use std::sync::Mutex;
-use std::sync::{mpsc, Arc};
+use std::sync::mpsc::TryRecvError;
+use std::sync::{Arc, mpsc};
 
 use super::*;
 
@@ -75,7 +75,7 @@ impl WritableJournal for PipeJournalTx {
                 record: entry,
             })
             .map_err(|err| {
-                anyhow::format_err!("failed to send journal event through the pipe - {}", err)
+                anyhow::format_err!("failed to send journal event through the pipe - {err}")
             })?;
         sender.offset += entry_size;
         Ok(LogWriteResult {
diff --git a/lib/journal/src/concrete/printing.rs b/lib/journal/src/concrete/printing.rs
index bea5041c9d..5d6086dba0 100644
--- a/lib/journal/src/concrete/printing.rs
+++ b/lib/journal/src/concrete/printing.rs
@@ -5,16 +5,12 @@ use lz4_flex::block::uncompressed_size;
 use wasmer_wasix_types::wasi;
 
 /// Type of printing mode to use
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub enum JournalPrintingMode {
+    #[default]
     Text,
     Json,
 }
-impl Default for JournalPrintingMode {
-    fn default() -> Self {
-        Self::Text
-    }
-}
 
 /// The printing journal writes all the journal entries to the console
 /// as either text or json.
@@ -42,7 +38,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 +63,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 +86,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,66 +96,72 @@ 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={fd}, offset={offset}, whence={whence:?})")
             }
-            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => write!(
-                f,
-                "fd-seek (fd={}, offset={}, whence={:?})",
-                fd, offset, whence
-            ),
             JournalEntry::FileDescriptorWriteV1 {
                 fd, offset, data, ..
             } => write!(
                 f,
-                "fd-write (fd={}, offset={}, data.len={})",
-                fd,
-                offset,
+                "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
+                "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,
@@ -168,8 +170,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 ..
             } => write!(
                 f,
-                "path-set-times (path={}, atime={}, mtime={}))",
-                path, st_atim, st_mtim
+                "path-set-times (path={path}, atime={st_atim}, mtime={st_mtim}))"
             ),
             JournalEntry::FileDescriptorSetTimesV1 {
                 fd,
@@ -178,11 +179,13 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 ..
             } => write!(
                 f,
-                "fd-set-times (fd={}, atime={}, mtime={})",
-                fd, st_atim, st_mtim
+                "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,
@@ -190,59 +193,54 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 fs_rights_inheriting,
             } => write!(
                 f,
-                "fd-set-rights (fd={}, base={:?}, inherited={:?})",
-                fd, fs_rights_base, fs_rights_inheriting
+                "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::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,19 +249,18 @@ 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,
@@ -272,8 +269,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
             } => {
                 write!(
                     f,
-                    "sock-connect (fd={}, addr={}, peer={})",
-                    fd, local_addr, peer_addr
+                    "sock-connect (fd={fd}, addr={local_addr}, peer={peer_addr})"
                 )
             }
             JournalEntry::SocketAcceptedV1 {
@@ -284,8 +280,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 ..
             } => write!(
                 f,
-                "sock-accept (listen-fd={}, sock_fd={}, addr={}, peer={})",
-                listen_fd, fd, local_addr, peer_addr
+                "sock-accept (listen-fd={listen_fd}, sock_fd={fd}, addr={local_addr}, peer={peer_addr})"
             ),
             JournalEntry::SocketJoinIpv4MulticastV1 {
                 fd,
@@ -293,8 +288,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 iface,
             } => write!(
                 f,
-                "sock-join-mcast-ipv4 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
+                "sock-join-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"
             ),
             JournalEntry::SocketJoinIpv6MulticastV1 {
                 fd,
@@ -302,8 +296,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 iface,
             } => write!(
                 f,
-                "sock-join-mcast-ipv6 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
+                "sock-join-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"
             ),
             JournalEntry::SocketLeaveIpv4MulticastV1 {
                 fd,
@@ -311,8 +304,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 iface,
             } => write!(
                 f,
-                "sock-leave-mcast-ipv4 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
+                "sock-leave-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"
             ),
             JournalEntry::SocketLeaveIpv6MulticastV1 {
                 fd,
@@ -320,8 +312,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 iface,
             } => write!(
                 f,
-                "sock-leave-mcast-ipv6 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
+                "sock-leave-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"
             ),
             JournalEntry::SocketSendFileV1 {
                 socket_fd,
@@ -330,33 +321,34 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 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
+                "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..d276c8ddec 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::{
+        Serializer,
+        allocator::{Arena, ArenaHandle},
+        sharing::Share,
+    },
 };
 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..356bf8d6ae 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,13 +5,13 @@ 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};
 
-use crate::{base64, SnapshotTrigger};
+use crate::{SnapshotTrigger, base64};
 
 type Fd = u32;
 
@@ -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..8dcefe91e6 100644
--- a/lib/middlewares/Cargo.toml
+++ b/lib/middlewares/Cargo.toml
@@ -13,15 +13,24 @@ 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 = "=7.0.0", default-features = false, features = [
+	"compiler",
+	"wasmparser",
+	"headless"
+] }
+wasmer-types = { path = "../types", version = "=7.0.0" }
+wasmer-vm = { path = "../vm", version = "=7.0.0" }
 
 [dev-dependencies]
-wasmer = { path = "../api", version = "=4.3.7", features = ["compiler"] }
+wasmer = { path = "../api", version = "=7.0.0", features = [
+	"compiler",
+	"singlepass",
+	"wasmparser",
+] }
 
 [badges]
 maintenance = { status = "actively-developed" }
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
+features = ["wasmer/cranelift"]
diff --git a/lib/middlewares/src/lib.rs b/lib/middlewares/src/lib.rs
index 5d914647ff..bbd0716b6a 100644
--- a/lib/middlewares/src/lib.rs
+++ b/lib/middlewares/src/lib.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod metering;
 
diff --git a/lib/middlewares/src/metering.rs b/lib/middlewares/src/metering.rs
index d374f21cf7..7f277f73de 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,
+    AsStoreMut, ExportIndex, GlobalInit, GlobalType, Instance, LocalFunctionIndex, Mutability,
+    Type,
+    sys::{FunctionMiddleware, MiddlewareError, MiddlewareReaderState, ModuleMiddleware},
 };
 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,
@@ -161,7 +166,9 @@ impl<F: Fn(&Operator) -> u64 + Send + Sync + 'static> ModuleMiddleware for Meter
         let mut global_indexes = self.global_indexes.lock().unwrap();
 
         if global_indexes.is_some() {
-            panic!("Metering::transform_module_info: Attempting to use a `Metering` middleware from multiple modules.");
+            panic!(
+                "Metering::transform_module_info: Attempting to use a `Metering` middleware from multiple modules."
+            );
         }
 
         // Append a global for remaining points and initialize it.
@@ -201,6 +208,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 +264,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);
 
@@ -263,14 +305,14 @@ impl<'a, F: Fn(&Operator) -> u64 + Send + Sync> FunctionMiddleware<'a> for Funct
     }
 }
 
-/// Get the remaining points in an [`Instance`][wasmer::Instance].
+/// Get the remaining points in an [`Instance`].
 ///
 /// Note: This can be used in a headless engine after an ahead-of-time
 /// compilation as all required state lives in the instance.
 ///
 /// # Panic
 ///
-/// The [`Instance`][wasmer::Instance) must have been processed with
+/// The [`Instance`] must have been processed with
 /// the [`Metering`] middleware at compile time, otherwise this will
 /// panic.
 ///
@@ -311,15 +353,14 @@ pub fn get_remaining_points(ctx: &mut impl AsStoreMut, instance: &Instance) -> M
     MeteringPoints::Remaining(points)
 }
 
-/// Set the new provided remaining points in an
-/// [`Instance`][wasmer::Instance].
+/// Set the new provided remaining points in an [`Instance`].
 ///
 /// Note: This can be used in a headless engine after an ahead-of-time
 /// compilation as all required state lives in the instance.
 ///
 /// # Panic
 ///
-/// The given [`Instance`][wasmer::Instance] must have been processed
+/// The given [`Instance`] must have been processed
 /// with the [`Metering`] middleware at compile time, otherwise this
 /// will panic.
 ///
@@ -359,7 +400,11 @@ mod tests {
 
     use std::sync::Arc;
     use wasmer::sys::EngineBuilder;
-    use wasmer::{imports, wat2wasm, CompilerConfig, Cranelift, Module, Store, TypedFunction};
+    use wasmer::{
+        Module, Store, TypedFunction, imports,
+        sys::{CompilerConfig, Cranelift},
+        wat2wasm,
+    };
 
     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/object/src/module.rs b/lib/object/src/module.rs
deleted file mode 100644
index 333980e30d..0000000000
--- a/lib/object/src/module.rs
+++ /dev/null
@@ -1,469 +0,0 @@
-use crate::error::ObjectError;
-use object::write::{
-    Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolSection,
-};
-use object::{
-    elf, macho, FileFlags, RelocationEncoding, RelocationKind, SectionKind, SymbolFlags,
-    SymbolKind, SymbolScope,
-};
-use wasmer_types::entity::PrimaryMap;
-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";
-
-/// Create an object for a given target `Triple`.
-///
-/// # Usage
-///
-/// ```rust
-/// # use wasmer_types::Triple;
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::get_object_for_target;
-///
-/// # fn generate_object_for_target(triple: &Triple) -> Result<(), ObjectError> {
-/// let mut object = get_object_for_target(&triple)?;
-///
-/// # Ok(())
-/// # }
-/// ```
-pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
-    let obj_binary_format = match triple.binary_format {
-        BinaryFormat::Elf => object::BinaryFormat::Elf,
-        BinaryFormat::Macho => object::BinaryFormat::MachO,
-        BinaryFormat::Coff => object::BinaryFormat::Coff,
-        binary_format => {
-            return Err(ObjectError::UnsupportedBinaryFormat(format!(
-                "{}",
-                binary_format
-            )));
-        }
-    };
-    let obj_architecture = match triple.architecture {
-        Architecture::X86_64 => object::Architecture::X86_64,
-        Architecture::Aarch64(_) => object::Architecture::Aarch64,
-        Architecture::Riscv64(_) => object::Architecture::Riscv64,
-        architecture => {
-            return Err(ObjectError::UnsupportedArchitecture(format!(
-                "{}",
-                architecture
-            )));
-        }
-    };
-    let obj_endianness = match triple
-        .endianness()
-        .map_err(|_| ObjectError::UnknownEndianness)?
-    {
-        Endianness::Little => object::Endianness::Little,
-        Endianness::Big => object::Endianness::Big,
-    };
-
-    let mut object = Object::new(obj_binary_format, obj_architecture, obj_endianness);
-
-    if let Architecture::Riscv64(_) = triple.architecture {
-        object.flags = FileFlags::Elf {
-            e_flags: elf::EF_RISCV_FLOAT_ABI_DOUBLE,
-            os_abi: 2,
-            abi_version: 0,
-        };
-    }
-
-    Ok(object)
-}
-
-/// Write data into an existing object.
-///
-/// # Usage
-///
-/// ```rust
-/// # use wasmer_types::Triple;
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::{get_object_for_target, emit_data};
-///
-/// # fn emit_data_into_object(triple: &Triple) -> Result<(), ObjectError> {
-/// let mut object = get_object_for_target(&triple)?;
-/// emit_data(&mut object, b"WASMER_METADATA", &b"Hello, World!"[..], 1)?;
-///
-/// # Ok(())
-/// # }
-/// ```
-pub fn emit_data(
-    obj: &mut Object,
-    name: &[u8],
-    data: &[u8],
-    align: u64,
-) -> Result<(), ObjectError> {
-    let symbol_id = obj.add_symbol(ObjSymbol {
-        name: name.to_vec(),
-        value: 0,
-        size: 0,
-        kind: SymbolKind::Data,
-        scope: SymbolScope::Dynamic,
-        weak: false,
-        section: SymbolSection::Undefined,
-        flags: SymbolFlags::None,
-    });
-    let section_id = obj.section_id(StandardSection::Data);
-    obj.add_symbol_data(symbol_id, section_id, data, align);
-
-    Ok(())
-}
-
-/// Emit the compilation result into an existing object.
-///
-/// # Usage
-///
-/// ```rust
-/// # use wasmer_types::SymbolRegistry;
-/// # use wasmer_types::{Compilation, Triple};
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::{get_object_for_target, emit_compilation};
-///
-/// # fn emit_compilation_into_object(
-/// #     triple: &Triple,
-/// #     compilation: Compilation,
-/// #     symbol_registry: impl SymbolRegistry,
-/// # ) -> Result<(), ObjectError> {
-/// let mut object = get_object_for_target(&triple)?;
-/// emit_compilation(&mut object, compilation, &symbol_registry, &triple)?;
-/// # Ok(())
-/// # }
-/// ```
-pub fn emit_compilation(
-    obj: &mut Object,
-    compilation: Compilation,
-    symbol_registry: &impl SymbolRegistry,
-    triple: &Triple,
-) -> Result<(), ObjectError> {
-    let mut function_bodies = PrimaryMap::with_capacity(compilation.functions.len());
-    let mut function_relocations = PrimaryMap::with_capacity(compilation.functions.len());
-    for (_, func) in compilation.functions.into_iter() {
-        function_bodies.push(func.body);
-        function_relocations.push(func.relocations);
-    }
-    let custom_section_relocations = compilation
-        .custom_sections
-        .iter()
-        .map(|(_, section)| section.relocations.clone())
-        .collect::<PrimaryMap<SectionIndex, _>>();
-
-    let debug_index = compilation.debug.map(|d| d.eh_frame);
-
-    let align = match triple.architecture {
-        Architecture::X86_64 => 1,
-        // In Arm64 is recommended a 4-byte alignment
-        Architecture::Aarch64(_) => 4,
-        _ => 1,
-    };
-
-    // Add sections
-    let custom_section_ids = compilation
-        .custom_sections
-        .into_iter()
-        .map(|(section_index, custom_section)| {
-            if debug_index.map_or(false, |d| d == 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);
-                let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
-                let symbol_id = obj.add_symbol(ObjSymbol {
-                    name: section_name.into_bytes(),
-                    value: 0,
-                    size: custom_section.bytes.len() as _,
-                    kind: SymbolKind::Data,
-                    scope: SymbolScope::Compilation,
-                    weak: false,
-                    section: SymbolSection::Section(section_id),
-                    flags: SymbolFlags::None,
-                });
-                (section_id, symbol_id)
-            } else {
-                let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
-                let (section_kind, standard_section) = match custom_section.protection {
-                    CustomSectionProtection::ReadExecute => {
-                        (SymbolKind::Text, StandardSection::Text)
-                    }
-                    CustomSectionProtection::Read => (SymbolKind::Data, StandardSection::Data),
-                };
-                let section_id = obj.section_id(standard_section);
-                let symbol_id = obj.add_symbol(ObjSymbol {
-                    name: section_name.into_bytes(),
-                    value: 0,
-                    size: custom_section.bytes.len() as _,
-                    kind: section_kind,
-                    scope: SymbolScope::Dynamic,
-                    weak: false,
-                    section: SymbolSection::Section(section_id),
-                    flags: SymbolFlags::None,
-                });
-                obj.add_symbol_data(
-                    symbol_id,
-                    section_id,
-                    custom_section.bytes.as_slice(),
-                    align,
-                );
-                (section_id, symbol_id)
-            }
-        })
-        .collect::<PrimaryMap<SectionIndex, _>>();
-
-    // Add functions
-    let function_symbol_ids = function_bodies
-        .into_iter()
-        .map(|(function_local_index, function)| {
-            let function_name =
-                symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
-            let section_id = obj.section_id(StandardSection::Text);
-            let symbol_id = obj.add_symbol(ObjSymbol {
-                name: function_name.into_bytes(),
-                value: 0,
-                size: function.body.len() as _,
-                kind: SymbolKind::Text,
-                scope: SymbolScope::Dynamic,
-                weak: false,
-                section: SymbolSection::Section(section_id),
-                flags: SymbolFlags::None,
-            });
-            obj.add_symbol_data(symbol_id, section_id, &function.body, align);
-            (section_id, symbol_id)
-        })
-        .collect::<PrimaryMap<LocalFunctionIndex, _>>();
-
-    // Add function call trampolines
-    for (signature_index, function) in compilation.function_call_trampolines.into_iter() {
-        let function_name =
-            symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(signature_index));
-        let section_id = obj.section_id(StandardSection::Text);
-        let symbol_id = obj.add_symbol(ObjSymbol {
-            name: function_name.into_bytes(),
-            value: 0,
-            size: function.body.len() as _,
-            kind: SymbolKind::Text,
-            scope: SymbolScope::Dynamic,
-            weak: false,
-            section: SymbolSection::Section(section_id),
-            flags: SymbolFlags::None,
-        });
-        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
-    }
-
-    // Add dynamic function trampolines
-    for (func_index, function) in compilation.dynamic_function_trampolines.into_iter() {
-        let function_name =
-            symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
-        let section_id = obj.section_id(StandardSection::Text);
-        let symbol_id = obj.add_symbol(ObjSymbol {
-            name: function_name.into_bytes(),
-            value: 0,
-            size: function.body.len() as _,
-            kind: SymbolKind::Text,
-            scope: SymbolScope::Dynamic,
-            weak: false,
-            section: SymbolSection::Section(section_id),
-            flags: SymbolFlags::None,
-        });
-        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
-    }
-
-    let mut all_relocations = Vec::new();
-
-    for (function_local_index, relocations) in function_relocations.into_iter() {
-        let (section_id, symbol_id) = function_symbol_ids.get(function_local_index).unwrap();
-        all_relocations.push((*section_id, *symbol_id, relocations))
-    }
-
-    for (section_index, relocations) in custom_section_relocations.into_iter() {
-        if !debug_index.map_or(false, |d| d == 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));
-        }
-    }
-
-    for (section_id, symbol_id, relocations) in all_relocations.into_iter() {
-        let (_symbol_id, section_offset) = obj.symbol_section_and_offset(symbol_id).unwrap();
-
-        for r in relocations {
-            let relocation_address = section_offset + r.offset as u64;
-
-            let (relocation_kind, relocation_encoding, relocation_size) = match r.kind {
-                Reloc::Abs4 => (RelocationKind::Absolute, RelocationEncoding::Generic, 32),
-                Reloc::Abs8 => (RelocationKind::Absolute, RelocationEncoding::Generic, 64),
-                Reloc::X86PCRel4 => (RelocationKind::Relative, RelocationEncoding::Generic, 32),
-                Reloc::X86CallPCRel4 => {
-                    (RelocationKind::Relative, RelocationEncoding::X86Branch, 32)
-                }
-                Reloc::X86CallPLTRel4 => (
-                    RelocationKind::PltRelative,
-                    RelocationEncoding::X86Branch,
-                    32,
-                ),
-                Reloc::X86GOTPCRel4 => {
-                    (RelocationKind::GotRelative, RelocationEncoding::Generic, 32)
-                }
-                Reloc::Arm64Call => (
-                    match obj.format() {
-                        object::BinaryFormat::Elf => RelocationKind::Elf(elf::R_AARCH64_CALL26),
-                        object::BinaryFormat::MachO => RelocationKind::MachO {
-                            value: macho::ARM64_RELOC_BRANCH26,
-                            relative: true,
-                        },
-                        fmt => panic!("unsupported binary format {:?}", fmt),
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::ElfX86_64TlsGd => (
-                    RelocationKind::Elf(elf::R_X86_64_TLSGD),
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                other => {
-                    return Err(ObjectError::UnsupportedArchitecture(format!(
-                        "{} (relocation: {}",
-                        triple.architecture, other
-                    )))
-                }
-            };
-
-            match r.reloc_target {
-                RelocationTarget::LocalFunc(index) => {
-                    let (_, target_symbol) = function_symbol_ids.get(index).unwrap();
-                    obj.add_relocation(
-                        section_id,
-                        Relocation {
-                            offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
-                            symbol: *target_symbol,
-                            addend: r.addend,
-                        },
-                    )
-                    .map_err(ObjectError::Write)?;
-                }
-                RelocationTarget::LibCall(libcall) => {
-                    let libcall_fn_name = libcall.to_function_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 {
-                            name: libcall_fn_name.to_vec(),
-                            value: 0,
-                            size: 0,
-                            kind: SymbolKind::Unknown,
-                            scope: SymbolScope::Unknown,
-                            weak: false,
-                            section: SymbolSection::Undefined,
-                            flags: SymbolFlags::None,
-                        })
-                    });
-                    obj.add_relocation(
-                        section_id,
-                        Relocation {
-                            offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
-                            symbol: target_symbol,
-                            addend: r.addend,
-                        },
-                    )
-                    .map_err(ObjectError::Write)?;
-                }
-                RelocationTarget::CustomSection(section_index) => {
-                    let (_, target_symbol) = custom_section_ids.get(section_index).unwrap();
-                    obj.add_relocation(
-                        section_id,
-                        Relocation {
-                            offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
-                            symbol: *target_symbol,
-                            addend: r.addend,
-                        },
-                    )
-                    .map_err(ObjectError::Write)?;
-                }
-            };
-        }
-    }
-
-    Ok(())
-}
-
-/// Emit the compilation result into an existing object.
-///
-/// # 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};
-///
-/// # fn emit_compilation_into_object(
-/// #     triple: &Triple,
-/// #     compilation: Compilation,
-/// #     symbol_registry: impl SymbolRegistry,
-/// # ) -> Result<(), ObjectError> {
-/// let bytes = &[ /* compilation bytes */];
-/// let mut object = get_object_for_target(&triple)?;
-/// emit_serialized(&mut object, bytes, &triple, "WASMER_MODULE")?;
-/// # Ok(())
-/// # }
-/// ```
-pub fn emit_serialized(
-    obj: &mut Object,
-    sercomp: &[u8],
-    triple: &Triple,
-    object_name: &str,
-) -> 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 metadata_name = "WASMER_MODULE_METADATA";
-
-    let align = match triple.architecture {
-        Architecture::X86_64 => 1,
-        // In Arm64 is recommended a 4-byte alignment
-        Architecture::Aarch64(_) => 4,
-        _ => 1,
-    };
-
-    let len = sercomp.len();
-    let section_id = obj.section_id(StandardSection::Data);
-    let symbol_id = obj.add_symbol(ObjSymbol {
-        name: len_name.as_bytes().to_vec(),
-        value: 0,
-        size: len.to_le_bytes().len() as _,
-        kind: SymbolKind::Data,
-        scope: SymbolScope::Dynamic,
-        weak: false,
-        section: SymbolSection::Section(section_id),
-        flags: SymbolFlags::None,
-    });
-    obj.add_symbol_data(symbol_id, section_id, &len.to_le_bytes(), align);
-
-    let section_id = obj.section_id(StandardSection::Data);
-    let symbol_id = obj.add_symbol(ObjSymbol {
-        name: data_name.as_bytes().to_vec(),
-        value: 0,
-        size: sercomp.len() as _,
-        kind: SymbolKind::Data,
-        scope: SymbolScope::Dynamic,
-        weak: false,
-        section: SymbolSection::Section(section_id),
-        flags: SymbolFlags::None,
-    });
-    obj.add_symbol_data(symbol_id, section_id, sercomp, align);
-
-    Ok(())
-}
diff --git a/lib/package/Cargo.toml b/lib/package/Cargo.toml
new file mode 100644
index 0000000000..18e343cd45
--- /dev/null
+++ b/lib/package/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "wasmer-package"
+version = "0.700.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.700.0", path = "../config" }
+wasmer-types = { version = "7.0.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 = { workspace = true, 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.workspace = true
+ureq.workspace = true
+hexdump.workspace = true
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..732707e4f2
--- /dev/null
+++ b/lib/package/src/convert/webc_to_package.rs
@@ -0,0 +1,352 @@
+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 package.
+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)
+                && let Some(sco) = manifest_atom
+                    .annotations
+                    .get(SuggestedCompilerOptimizations::KEY)
+                && 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 package 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..bca3b2f82c
--- /dev/null
+++ b/lib/package/src/package/manifest.rs
@@ -0,0 +1,1429 @@
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+};
+
+use ciborium::{Value, cbor};
+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::{
+    Atom, Binding, Command, Manifest as WebcManifest, UrlOrManifest, WaiBindings, WitBindings,
+    annotations::{
+        Atom as AtomAnnotation, FileSystemMapping, FileSystemMappings, VolumeSpecificPath, Wapm,
+        Wasi,
+    },
+};
+
+use super::{FsVolume, Strictness};
+
+const METADATA_VOLUME: &str = FsVolume::METADATA;
+
+/// Errors that may occur when converting from a `wasmer_config::package::Manifest`
+/// into a WebC 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
+            && 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
+        && 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..d4df84327f
--- /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::{
+        Package, WalkBuilderFactory, WasmerPackageError, include_everything_walker,
+        wasmer_ignore_walker,
+    },
+    strictness::Strictness,
+    volume::{WasmerPackageVolume, fs::*, in_memory::*},
+};
+
+#[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..122dc012ad
--- /dev/null
+++ b/lib/package/src/package/package.rs
@@ -0,0 +1,2077 @@
+#![allow(
+    clippy::result_large_err,
+    reason = "WasmerPackageError is large, but not often used"
+)]
+
+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::{
+    AbstractVolume, AbstractWebc, Container, ContainerError, DetectError, PathSegment, Version,
+    Volume,
+    metadata::{Manifest as WebcManifest, annotations::Wapm},
+    v3::{
+        ChecksumAlgorithm, Timestamps,
+        write::{FileEntry, Writer},
+    },
+};
+
+use super::{
+    ManifestError, MemoryVolume, Strictness,
+    manifest::wasmer_manifest_to_webc,
+    volume::{WasmerPackageVolume, fs::FsVolume},
+};
+
+/// 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 produced by unpacking a
+    /// Wasmer package archive.
+    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 produced by unpacking a
+    /// Wasmer package archive.
+    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()
+            && let Some(parent) = current_exe.parent()
+            && 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::{Compression, write::GzEncoder};
+    use sha2::Digest;
+    use shared_buffer::OwnedBuffer;
+    use tempfile::TempDir;
+    use webc::{
+        PathSegment, PathSegments,
+        metadata::{
+            Binding, BindingsExtended, WaiBindings, WitBindings,
+            annotations::{FileSystemMapping, VolumeSpecificPath},
+        },
+    };
+
+    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..f5c14ac903
--- /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
+/// `Package` values from this crate.
+///
+/// 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..6077a191a4
--- /dev/null
+++ b/lib/package/src/package/volume/fs.rs
@@ -0,0 +1,565 @@
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fmt::Debug,
+    fs::File,
+    io::Read,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{Context, Error};
+use shared_buffer::OwnedBuffer;
+
+use webc::{
+    AbstractVolume, Metadata, PathSegment, PathSegments, Timestamps, ToPathSegments, sanitize_path,
+    v3::{
+        self,
+        write::{DirEntry, Directory, FileEntry},
+    },
+};
+
+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
+/// filesystem mappings. 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..5e47825c18
--- /dev/null
+++ b/lib/package/src/package/volume/in_memory.rs
@@ -0,0 +1,464 @@
+use std::{
+    collections::BTreeMap,
+    str::FromStr,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use webc::{
+    AbstractVolume, Metadata, PathSegment, PathSegments,
+    v3::{self, write::FileEntry},
+};
+
+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> {
+        self.node.as_directory_tree(strictness)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use sha2::{Digest, Sha256};
+    use v3::{
+        Checksum, ChecksumAlgorithm, Index, IndexEntry, Signature, SignatureAlgorithm, Span, Tag,
+        Timestamps, write::Writer,
+    };
+    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..28cff0e1cf
--- /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::{AbstractVolume, v3::write::Directory};
+
+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..073e5686e6
--- /dev/null
+++ b/lib/package/src/utils.rs
@@ -0,0 +1,206 @@
+#![allow(
+    clippy::result_large_err,
+    reason = "WasmerPackageError is large, but not often used"
+)]
+
+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..23291205b0
--- /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.700.0" }
+wasmer-config = { path = "../config", version = "=0.700.0" }
+wasmer-package = { path = "../package", version = "=0.700.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.workspace = true
+zip = { workspace = true, default-features = false, features = ["deflate"] }
+tracing.workspace = true
+ignore.workspace = true
+
+[dev-dependencies]
+rand.workspace = true
+tempfile.workspace = true
+url.workspace = true
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..a74ade961f
--- /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::{
+    WasmerClient,
+    types::{DeployApp, DeployAppVersion, PublishDeployAppVars},
+};
+use wasmer_config::{app::AppConfigV1, package::PackageSource};
+
+use crate::package::publish::{
+    PackagePublishError, PublishOptions, PublishProgress, PublishWait, publish_package_directory,
+};
+
+/// 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
+        && 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..67ace56049
--- /dev/null
+++ b/lib/sdk/src/app/deploy_remote_build.rs
@@ -0,0 +1,441 @@
+//! 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::{Context as _, bail};
+use futures_util::StreamExt;
+use reqwest::header::CONTENT_TYPE;
+use wasmer_backend_api::{
+    WasmerClient,
+    query::UploadMethod,
+    types::{AutoBuildDeployAppLogKind, AutobuildLog, DeployAppVersion, Id},
+};
+use wasmer_config::app::AppConfigV1;
+use zip::{CompressionMethod, write::SimpleFileOptions};
+
+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),
+        Some(UploadMethod::R2),
+    )
+    .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
+                && 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..1d111528ff
--- /dev/null
+++ b/lib/sdk/src/package/publish.rs
@@ -0,0 +1,382 @@
+//! 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, query::UploadMethod};
+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,
+            Some(UploadMethod::R2),
+        )
+        .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().is_none_or(|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().is_none_or(|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..d38897c5f8
--- /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::{PublishOptions, PublishWait, publish_package_directory};
+
+/// 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..013c50b214
--- /dev/null
+++ b/lib/swift/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "wasmer-swift"
+version = "0.700.0"
+description = "Experimental wasmer bindings for swift"
+edition.workspace = true
+license.workspace = true
+
+# 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 = { workspace = true, features = ["rt"], default-features = false }
+uniffi.workspace = true
+virtual-fs = { path = "../virtual-fs", version = "=0.700.0", default-features = false, features = [
+	"webc-fs",
+] }
+wasmer = { version = "=7.0.0", path = "../api", default-features = false, features = [
+	"wamr",
+	"std",
+] }
+wasmer-wasix = { version = "=0.700.0", path = "../wasix", default-features = false, features = [
+	"sys",
+] }
+webc.workspace = true
+wasmer-package.workspace = true
+
+
+[build-dependencies]
+uniffi = { workspace = true, features = ["build"] }
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys", "wasmer/cranelift"]
+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..b8a06d4b93
--- /dev/null
+++ b/lib/swift/src/lib.rs
@@ -0,0 +1,76 @@
+use std::sync::Arc;
+use tokio::runtime::Runtime;
+use virtual_fs::{AsyncReadExt, AsyncSeekExt};
+use wasmer_package::utils::from_bytes;
+use wasmer_wasix::{
+    PluggableRuntime,
+    bin_factory::BinaryPackage,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+    runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
+};
+
+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..e3b0467b54 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.700.0"
 description = "Wasmer utilities for a sys environment."
 categories = ["wasm"]
 keywords = ["wasm", "webassembly"]
@@ -12,20 +12,25 @@ 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 = "=7.0.0", default-features = false, features = ["sys", "compiler", "headless"] }
+wasmer-vm = { path = "../vm", version = "=7.0.0" }
+wasmer-types = { path = "../types", version = "=7.0.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 = "=7.0.0", default-features = false, features = ["sys", "compiler", "cranelift"] }
+tracing-subscriber = { workspace = true, features = ["fmt"] }
+tracing.workspace = true
 
 [package.metadata.docs.rs]
+features = ["wasmer/cranelift"]
 rustc-args = ["--cfg", "docsrs"]
+
+[features]
+default = []
+tracing = []
diff --git a/lib/sys-utils/src/lib.rs b/lib/sys-utils/src/lib.rs
index d0e931c7fd..2563a4dff9 100644
--- a/lib/sys-utils/src/lib.rs
+++ b/lib/sys-utils/src/lib.rs
@@ -1,2 +1,2 @@
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 pub mod memory;
diff --git a/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs b/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs
index aeb2f6acad..caf0c44fa5 100644
--- a/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs
+++ b/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs
@@ -6,11 +6,6 @@ use std::{
     ptr, slice,
 };
 
-// /// Round `size` up to the nearest multiple of `page_size`.
-// fn round_up_to_page_size(size: usize, page_size: usize) -> usize {
-//     (size + (page_size - 1)) & !(page_size - 1)
-// }
-
 /// A simple struct consisting of a page-aligned pointer to page-aligned
 /// and initially-zeroed memory and a length.
 #[derive(Debug)]
@@ -65,13 +60,6 @@ impl FdMmap {
         }
     }
 
-    // /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory.
-    // pub fn with_at_least(size: usize) -> Result<Self, String> {
-    //     let page_size = region::page::size();
-    //     let rounded_size = round_up_to_page_size(size, page_size);
-    //     Self::accessible_reserved(rounded_size, rounded_size)
-    // }
-
     /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory,
     /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size`
     /// must be native page-size multiples.
@@ -346,14 +334,6 @@ fn copy_file_range(
 mod tests {
     use super::*;
 
-    // #[test]
-    // fn test_round_up_to_page_size() {
-    //     assert_eq!(round_up_to_page_size(0, 4096), 0);
-    //     assert_eq!(round_up_to_page_size(1, 4096), 4096);
-    //     assert_eq!(round_up_to_page_size(4096, 4096), 4096);
-    //     assert_eq!(round_up_to_page_size(4097, 4096), 8192);
-    // }
-
     #[cfg(target_family = "unix")]
     #[test]
     fn test_copy_file_range() -> Result<(), std::io::Error> {
diff --git a/lib/sys-utils/src/memory/fd_memory/memories.rs b/lib/sys-utils/src/memory/fd_memory/memories.rs
index f11e35ce21..4f57b54c26 100644
--- a/lib/sys-utils/src/memory/fd_memory/memories.rs
+++ b/lib/sys-utils/src/memory/fd_memory/memories.rs
@@ -63,13 +63,13 @@ impl WasmMmap {
             })?;
         let prev_pages = self.size;
 
-        if let Some(maximum) = conf.maximum {
-            if new_pages > maximum {
-                return Err(MemoryError::CouldNotGrow {
-                    current: self.size,
-                    attempted_delta: delta,
-                });
-            }
+        if let Some(maximum) = conf.maximum
+            && new_pages > maximum
+        {
+            return Err(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            });
         }
 
         // Wasm linear memories are never allowed to grow beyond what is
@@ -226,7 +226,7 @@ impl VMOwnedMemory {
         style: &MemoryStyle,
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
-        Self::new_internal(memory, style, Some(vm_memory_location))
+        unsafe { Self::new_internal(memory, style, Some(vm_memory_location)) }
     }
 
     /// Build a `Memory` with either self-owned or VM owned metadata.
@@ -281,7 +281,7 @@ impl VMOwnedMemory {
             vm_memory_definition: if let Some(mem_loc) = vm_memory_location {
                 {
                     let mut ptr = mem_loc;
-                    let md = ptr.as_mut();
+                    let md = unsafe { ptr.as_mut() };
                     md.base = base_ptr;
                     md.current_length = mem_length;
                 }
@@ -412,7 +412,8 @@ impl VMSharedMemory {
         style: &MemoryStyle,
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
-        Ok(VMOwnedMemory::from_definition(memory, style, vm_memory_location)?.to_shared())
+        let owned = unsafe { VMOwnedMemory::from_definition(memory, style, vm_memory_location)? };
+        Ok(owned.to_shared())
     }
 
     /// Copies this memory to a new memory
@@ -487,15 +488,29 @@ impl LinearMemory for VMSharedMemory {
         Ok(Box::new(forked))
     }
 
-    fn do_wait(
+    unsafe fn do_wait(
         &mut self,
-        dst: wasmer_vm::NotifyLocation,
+        dst: u32,
+        expected: wasmer_vm::ExpectedValue,
         timeout: Option<std::time::Duration>,
     ) -> Result<u32, WaiterError> {
-        self.conditions.do_wait(dst, timeout)
+        unsafe {
+            let dst = wasmer_vm::NotifyLocation {
+                address: dst,
+                memory_base: self
+                    .mmap
+                    .read()
+                    .unwrap()
+                    .vm_memory_definition
+                    .as_ptr()
+                    .as_ref()
+                    .base,
+            };
+            self.conditions.do_wait(dst, expected, timeout)
+        }
     }
 
-    fn do_notify(&mut self, dst: wasmer_vm::NotifyLocation, count: u32) -> u32 {
+    fn do_notify(&mut self, dst: u32, count: u32) -> u32 {
         self.conditions.do_notify(dst, count)
     }
 }
@@ -570,7 +585,7 @@ impl LinearMemory for VMMemory {
 
     /// Initialize memory with data
     unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
-        self.0.initialize_with_data(start, data)
+        unsafe { self.0.initialize_with_data(start, data) }
     }
 
     /// Copies this memory to a new memory
@@ -611,17 +626,13 @@ impl VMMemory {
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
         Ok(if memory.shared {
-            Self(Box::new(VMSharedMemory::from_definition(
-                memory,
-                style,
-                vm_memory_location,
-            )?))
+            let shared =
+                unsafe { VMSharedMemory::from_definition(memory, style, vm_memory_location)? };
+            Self(Box::new(shared))
         } else {
-            Self(Box::new(VMOwnedMemory::from_definition(
-                memory,
-                style,
-                vm_memory_location,
-            )?))
+            let owned =
+                unsafe { VMOwnedMemory::from_definition(memory, style, vm_memory_location)? };
+            Self(Box::new(owned))
         })
     }
 
@@ -649,7 +660,7 @@ pub unsafe fn initialize_memory_with_data(
     start: usize,
     data: &[u8],
 ) -> Result<(), Trap> {
-    let mem_slice = std::slice::from_raw_parts_mut(memory.base, memory.current_length);
+    let mem_slice = unsafe { std::slice::from_raw_parts_mut(memory.base, memory.current_length) };
     let end = start + data.len();
     let to_init = &mut mem_slice[start..end];
     to_init.copy_from_slice(data);
diff --git a/lib/sys-utils/src/memory/fd_memory/mod.rs b/lib/sys-utils/src/memory/fd_memory/mod.rs
index 330c2c4875..877377c415 100644
--- a/lib/sys-utils/src/memory/fd_memory/mod.rs
+++ b/lib/sys-utils/src/memory/fd_memory/mod.rs
@@ -1,4 +1,4 @@
 mod fd_mmap;
 mod memories;
 
-pub use self::memories::{initialize_memory_with_data, VMMemory, VMOwnedMemory, VMSharedMemory};
+pub use self::memories::{VMMemory, VMOwnedMemory, VMSharedMemory, initialize_memory_with_data};
diff --git a/lib/types/Cargo.toml b/lib/types/Cargo.toml
index d36bb7fafd..204914fd1c 100644
--- a/lib/types/Cargo.toml
+++ b/lib/types/Cargo.toml
@@ -13,24 +13,25 @@ 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"
-xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
-sha2 = { version = "0.10" }
-hex = { version = "^0.4" }
+bytecheck.workspace = true
+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 +41,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..7d2e1c65f0 100644
--- a/lib/types/src/entity/boxed_slice.rs
+++ b/lib/types/src/entity/boxed_slice.rs
@@ -3,9 +3,9 @@
 
 //! Boxed slices for `PrimaryMap`.
 
+use crate::entity::EntityRef;
 use crate::entity::iter::{Iter, IterMut};
 use crate::entity::keys::Keys;
-use crate::entity::EntityRef;
 use crate::lib::std::boxed::Box;
 use crate::lib::std::marker::PhantomData;
 use crate::lib::std::ops::{Index, IndexMut};
@@ -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,
@@ -35,9 +51,11 @@ where
     ///
     /// This relies on `raw` pointing to a valid slice of `V`s.
     pub unsafe fn from_raw(raw: *mut [V]) -> Self {
-        Self {
-            elems: Box::from_raw(raw),
-            unused: PhantomData,
+        unsafe {
+            Self {
+                elems: Box::from_raw(raw),
+                unused: PhantomData,
+            }
         }
     }
 
@@ -72,22 +90,22 @@ where
     }
 
     /// Iterate over all the values in this map.
-    pub fn values(&self) -> slice::Iter<V> {
+    pub fn values(&self) -> slice::Iter<'_, V> {
         self.elems.iter()
     }
 
     /// Iterate over all the values in this map, mutable edition.
-    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+    pub fn values_mut(&mut self) -> slice::IterMut<'_, V> {
         self.elems.iter_mut()
     }
 
     /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         Iter::new(self.elems.iter())
     }
 
     /// Iterate over all the keys and values in this map, mutable edition.
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         IterMut::new(self.elems.iter_mut())
     }
 
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/packed_option.rs b/lib/types/src/entity/packed_option.rs
index ce67e75258..afc68b401e 100644
--- a/lib/types/src/entity/packed_option.rs
+++ b/lib/types/src/entity/packed_option.rs
@@ -42,11 +42,7 @@ impl<T: ReservedValue> PackedOption<T> {
 
     /// Expand the packed option into a normal `Option`.
     pub fn expand(self) -> Option<T> {
-        if self.is_none() {
-            None
-        } else {
-            Some(self.0)
-        }
+        if self.is_none() { None } else { Some(self.0) }
     }
 
     /// Maps a `PackedOption<T>` to `Option<U>` by applying a function to a contained value.
diff --git a/lib/types/src/entity/primary_map.rs b/lib/types/src/entity/primary_map.rs
index a810791331..ada06b2f27 100644
--- a/lib/types/src/entity/primary_map.rs
+++ b/lib/types/src/entity/primary_map.rs
@@ -2,10 +2,10 @@
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
 //! Densely numbered entity references as mapping keys.
+use crate::entity::EntityRef;
 use crate::entity::boxed_slice::BoxedSlice;
 use crate::entity::iter::{IntoIter, Iter, IterMut};
 use crate::entity::keys::Keys;
-use crate::entity::EntityRef;
 use crate::lib::std::boxed::Box;
 use crate::lib::std::iter::FromIterator;
 use crate::lib::std::marker::PhantomData;
@@ -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,
@@ -94,22 +109,22 @@ where
     }
 
     /// Iterate over all the values in this map.
-    pub fn values(&self) -> slice::Iter<V> {
+    pub fn values(&self) -> slice::Iter<'_, V> {
         self.elems.iter()
     }
 
     /// Iterate over all the values in this map, mutable edition.
-    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+    pub fn values_mut(&mut self) -> slice::IterMut<'_, V> {
         self.elems.iter_mut()
     }
 
     /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         Iter::new(self.elems.iter())
     }
 
     /// Iterate over all the keys and values in this map, mutable edition.
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         IterMut::new(self.elems.iter_mut())
     }
 
@@ -268,12 +283,12 @@ where
     V::Archived: std::fmt::Debug,
 {
     /// Iterator over all values in the `ArchivedPrimaryMap`
-    pub fn values(&self) -> slice::Iter<Archived<V>> {
+    pub fn values(&self) -> slice::Iter<'_, Archived<V>> {
         self.elems.iter()
     }
 
     /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, Archived<V>> {
+    pub fn iter(&self) -> Iter<'_, K, Archived<V>> {
         Iter::new(self.elems.iter())
     }
 }
diff --git a/lib/types/src/entity/secondary_map.rs b/lib/types/src/entity/secondary_map.rs
index 554bc4278a..113f4c807b 100644
--- a/lib/types/src/entity/secondary_map.rs
+++ b/lib/types/src/entity/secondary_map.rs
@@ -3,9 +3,9 @@
 
 //! Densely numbered entity references as mapping keys.
 
+use crate::entity::EntityRef;
 use crate::entity::iter::{Iter, IterMut};
 use crate::entity::keys::Keys;
-use crate::entity::EntityRef;
 use crate::lib::std::cmp::min;
 use crate::lib::std::marker::PhantomData;
 use crate::lib::std::ops::{Index, IndexMut};
@@ -14,9 +14,9 @@ use crate::lib::std::vec::Vec;
 use rkyv::{Archive, Archived, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{
+    Deserialize, Serialize,
     de::{Deserializer, SeqAccess, Visitor},
     ser::{SerializeSeq, Serializer},
-    Deserialize, Serialize,
 };
 
 /// A mapping `K -> V` for densely indexed entity references.
@@ -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
@@ -106,12 +121,12 @@ where
     }
 
     /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         Iter::new(self.elems.iter())
     }
 
     /// Iterate over all the keys and values in this map, mutable edition.
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         IterMut::new(self.elems.iter_mut())
     }
 
@@ -121,12 +136,12 @@ where
     }
 
     /// Iterate over all the values in this map.
-    pub fn values(&self) -> slice::Iter<V> {
+    pub fn values(&self) -> slice::Iter<'_, V> {
         self.elems.iter()
     }
 
     /// Iterate over all the values in this map, mutable edition.
-    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+    pub fn values_mut(&mut self) -> slice::IterMut<'_, V> {
         self.elems.iter_mut()
     }
 
@@ -147,12 +162,12 @@ where
     }
 
     /// Iterator over all values in the `ArchivedPrimaryMap`
-    pub fn values(&self) -> slice::Iter<Archived<V>> {
+    pub fn values(&self) -> slice::Iter<'_, Archived<V>> {
         self.elems.iter()
     }
 
     /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, Archived<V>> {
+    pub fn iter(&self) -> Iter<'_, K, Archived<V>> {
         Iter::new(self.elems.iter())
     }
 }
diff --git a/lib/types/src/error.rs b/lib/types/src/error.rs
index 67af12987e..e1d0a793e6 100644
--- a/lib/types/src/error.rs
+++ b/lib/types/src/error.rs
@@ -1,5 +1,5 @@
 //! The WebAssembly possible errors
-use crate::{ExternType, Pages};
+use crate::{ExternType, Pages, progress::UserAbort};
 use std::io;
 use thiserror::Error;
 
@@ -142,13 +142,12 @@ use crate::lib::std::string::String;
 /// The WebAssembly.CompileError object indicates an error during
 /// WebAssembly decoding or validation.
 ///
-/// This is based on the [Wasm Compile Error][compile-error] API.
-///
-/// [compiler-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError
+/// This mirrors the WebAssembly `CompileError` API described at
+/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError>.
 #[derive(Debug)]
 #[cfg_attr(feature = "std", derive(Error))]
 pub enum CompileError {
-    /// A Wasm translation error occured.
+    /// A Wasm translation error occurred.
     #[cfg_attr(feature = "std", error("WebAssembly translation error: {0}"))]
     Wasm(WasmError),
 
@@ -179,6 +178,10 @@ pub enum CompileError {
     /// Middleware error occurred.
     #[cfg_attr(feature = "std", error("Middleware error: {0}"))]
     MiddlewareError(String),
+
+    /// Compilation aborted by a user callback.
+    #[cfg_attr(feature = "std", error("Compilation aborted: {0}"))]
+    Aborted(UserAbort),
 }
 
 impl From<WasmError> for CompileError {
@@ -187,6 +190,12 @@ impl From<WasmError> for CompileError {
     }
 }
 
+impl From<UserAbort> for CompileError {
+    fn from(abort: UserAbort) -> Self {
+        Self::Aborted(abort)
+    }
+}
+
 /// A error in the middleware.
 #[derive(Debug)]
 #[cfg_attr(feature = "std", derive(Error))]
@@ -262,7 +271,7 @@ impl From<MiddlewareError> for WasmError {
 }
 
 /// The error that can happen while parsing a `str`
-/// to retrieve a [`CpuFeature`](crate::CpuFeature).
+/// to retrieve a [`CpuFeature`](crate::target::CpuFeature).
 #[derive(Debug)]
 #[cfg_attr(feature = "std", derive(Error))]
 pub enum ParseCpuFeatureError {
@@ -294,7 +303,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/exception.rs b/lib/types/src/exception.rs
new file mode 100644
index 0000000000..deb8c5c282
--- /dev/null
+++ b/lib/types/src/exception.rs
@@ -0,0 +1,2 @@
+/// Special exception tag value used for catch_all clauses.
+pub const CATCH_ALL_TAG_VALUE: i32 = i32::MAX;
diff --git a/lib/types/src/features.rs b/lib/types/src/features.rs
index 54197762db..8cfdb81238 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
@@ -118,6 +157,22 @@ impl Features {
         self
     }
 
+    /// Configures whether the WebAssembly Relaxed SIMD proposal will be
+    /// enabled.
+    ///
+    /// The [WebAssembly Relaxed SIMD proposal][proposal] 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.
+    ///
+    /// [proposal]: https://github.com/WebAssembly/relaxed-simd
+    pub fn relaxed_simd(&mut self, enable: bool) -> &mut Self {
+        self.relaxed_simd = enable;
+        self
+    }
+
     /// Configures whether the WebAssembly bulk memory operations proposal will
     /// be enabled.
     ///
@@ -232,6 +287,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 +509,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..e0b6013d09 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, Hash),
+    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..69020d5108 100644
--- a/lib/types/src/lib.rs
+++ b/lib/types/src/lib.rs
@@ -17,7 +17,7 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(all(feature = "std", feature = "core"))]
 compile_error!(
@@ -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,13 +45,13 @@ 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 exception;
 mod features;
 mod indexes;
 mod initializers;
@@ -59,10 +59,12 @@ mod libcalls;
 mod memory;
 mod module;
 mod module_hash;
+mod progress;
 mod serialize;
 mod stack;
 mod store_id;
 mod table;
+pub mod target;
 mod trapcode;
 mod types;
 mod units;
@@ -70,14 +72,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 +82,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,
@@ -98,47 +92,28 @@ 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::module_hash::ModuleHash;
+pub use crate::progress::{CompilationProgress, CompilationProgressCallback, UserAbort};
+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::exception::CATCH_ALL_TAG_VALUE;
 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..7aaada05ac 100644
--- a/lib/types/src/libcalls.rs
+++ b/lib/types/src/libcalls.rs
@@ -1,4 +1,4 @@
-use enum_iterator::IntoEnumIterator;
+use enum_iterator::Sequence;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
@@ -8,20 +8,11 @@ use std::fmt;
 ///
 /// This list is likely to grow over time.
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    Hash,
-    IntoEnumIterator,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
-    rkyv::CheckBytes,
+    Copy, Clone, Debug, PartialEq, Eq, Hash, Sequence, 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, Hash, PartialEq, Eq), compare(PartialEq))]
 #[repr(u16)]
 pub enum LibCall {
     /// ceil.f32
@@ -133,8 +124,28 @@ pub enum LibCall {
     /// memory.atomic.notify for local memories
     Memory32AtomicNotify,
 
-    /// memory.atomic.botify for imported memories
+    /// memory.atomic.notify for imported memories
     ImportedMemory32AtomicNotify,
+
+    /// throw
+    Throw,
+
+    /// allocate exception object and get an exnref for it
+    AllocException,
+    /// Get the values buffer pointer out of an exnref
+    ReadExnRef,
+    /// Given a caught native exception pointer, get the exnref and delete the exception itself
+    LibunwindExceptionIntoExnRef,
+
+    /// The personality function
+    EHPersonality,
+    /// The second stage of the EH personality function
+    EHPersonality2,
+
+    /// debug_usize
+    DebugUsize,
+    /// debug_str
+    DebugStr,
 }
 
 impl LibCall {
@@ -183,6 +194,14 @@ 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::EHPersonality => "wasmer_eh_personality",
+            Self::EHPersonality2 => "wasmer_eh_personality2",
+            Self::AllocException => "wasmer_vm_alloc_exception",
+            Self::ReadExnRef => "wasmer_vm_read_exnref",
+            Self::LibunwindExceptionIntoExnRef => "wasmer_vm_exception_into_exnref",
+            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..51e352c0ba 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
     }
@@ -341,6 +356,11 @@ impl ModuleInfo {
         self.hash
     }
 
+    /// Returns the module hash as String if available
+    pub fn hash_string(&self) -> Option<String> {
+        self.hash.map(|m| m.to_string())
+    }
+
     /// Get the given passive element, if it exists.
     pub fn get_passive_element(&self, index: ElemIndex) -> Option<&[FunctionIndex]> {
         self.passive_elements.get(&index).map(|es| &**es)
@@ -362,7 +382,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 +402,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 +441,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 +547,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 {
@@ -520,6 +580,14 @@ impl ModuleInfo {
             .take(self.num_imported_functions)
             .map(move |sig_index| self.signatures[*sig_index].clone())
     }
+
+    /// Get the name of a function by its index.
+    pub fn get_function_name(&self, func_index: FunctionIndex) -> String {
+        self.function_names
+            .get(&func_index)
+            .cloned()
+            .unwrap_or_else(|| format!("function_{}", func_index.as_u32()))
+    }
 }
 
 impl fmt::Display for ModuleInfo {
diff --git a/lib/types/src/module_hash.rs b/lib/types/src/module_hash.rs
index 7c4e967f59..7bbec30a25 100644
--- a/lib/types/src/module_hash.rs
+++ b/lib/types/src/module_hash.rs
@@ -1,19 +1,13 @@
-use std::fmt::{self, Display, Formatter};
+use std::{
+    fmt::{self, Display, Formatter},
+    hash::Hash,
+};
 
-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;
 
-/// Hashing algorithm to be used for the module info
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum HashAlgorithm {
-    /// Sha256
-    Sha256,
-    /// XXHash
-    XXHash,
-}
-
 /// The hash of a WebAssembly module.
 #[derive(
     Debug,
@@ -28,51 +22,35 @@ 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
+    /// Deprecated.
     XXHash([u8; 8]),
 
     /// sha256
     Sha256([u8; 32]),
 }
 
-impl ModuleHash {
-    /// Create a new [`ModuleHash`] from the raw xxhash hash.
-    pub fn xxhash_from_bytes(key: [u8; 8]) -> Self {
-        Self::XXHash(key)
-    }
-
-    /// Create a new [`ModuleHash`] from the raw sha256 hash.
-    pub fn sha256_from_bytes(key: [u8; 32]) -> Self {
-        Self::Sha256(key)
-    }
-
-    /// Parse a XXHash hash from a hex-encoded string.
-    pub fn xxhash_parse_hex(hex_str: &str) -> Result<Self, hex::FromHexError> {
-        let mut hash = [0_u8; 8];
-        hex::decode_to_slice(hex_str, &mut hash)?;
-        Ok(Self::xxhash_from_bytes(hash))
-    }
-
-    /// Parse a Sha256 hash from a hex-encoded string.
-    pub fn sha256_parse_hex(hex_str: &str) -> Result<Self, hex::FromHexError> {
-        let mut hash = [0_u8; 32];
-        hex::decode_to_slice(hex_str, &mut hash)?;
-        Ok(Self::sha256_from_bytes(hash))
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for ModuleHash {
+    fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        match self {
+            Self::XXHash(_) => 8 * 8,
+            Self::Sha256(_) => 8 * 32,
+        }
     }
+}
 
-    /// Generate a new [`ModuleCache`] based on the XXHash hash of some bytes.
-    pub fn xxhash(wasm: impl AsRef<[u8]>) -> Self {
+impl ModuleHash {
+    /// Generate a new [`ModuleHash`] based on the Sha256 hash of some bytes.
+    pub fn new(wasm: impl AsRef<[u8]>) -> Self {
         let wasm = wasm.as_ref();
-
-        let hash = xxhash_rust::xxh64::xxh64(wasm, 0);
-
-        Self::XXHash(hash.to_ne_bytes())
+        let hash = sha2::Sha256::digest(wasm).into();
+        Self::Sha256(hash)
     }
 
-    /// 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 +59,18 @@ impl ModuleHash {
         Self::Sha256(hash)
     }
 
+    /// Create a new [`ModuleHash`] from the raw sha256 hash.
+    pub fn from_bytes(hash: [u8; 32]) -> Self {
+        Self::Sha256(hash)
+    }
+
+    /// Generate a random [`ModuleHash`]. For when you don't care about caches.
+    pub fn random() -> Self {
+        let mut bytes = [0_u8; _];
+        getrandom::getrandom(&mut bytes).unwrap();
+        Self::Sha256(bytes)
+    }
+
     /// Get the raw hash.
     pub fn as_bytes(&self) -> &[u8] {
         match self {
@@ -88,23 +78,15 @@ impl ModuleHash {
             Self::Sha256(bytes) => bytes.as_slice(),
         }
     }
+
+    /// Build a short hex representation of the hash (first 4 bytes).
+    pub fn short_hash(&self) -> String {
+        hex::encode_upper(&self.as_bytes()[..4])
+    }
 }
 
 impl Display for ModuleHash {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        fn format<const N: usize>(f: &mut Formatter<'_>, bytes: &[u8; N]) -> fmt::Result {
-            for byte in bytes {
-                write!(f, "{byte:02X}")?;
-            }
-
-            Ok(())
-        }
-
-        match self {
-            Self::XXHash(bytes) => format(f, bytes)?,
-            Self::Sha256(bytes) => format(f, bytes)?,
-        }
-
-        Ok(())
+        write!(f, "{}", hex::encode_upper(self.as_bytes()))
     }
 }
diff --git a/lib/types/src/progress.rs b/lib/types/src/progress.rs
new file mode 100644
index 0000000000..268db2c0d0
--- /dev/null
+++ b/lib/types/src/progress.rs
@@ -0,0 +1,100 @@
+//! Types used to report and handle compilation progress.
+
+use crate::lib::std::{borrow::Cow, fmt, string::String, sync::Arc};
+use thiserror::Error;
+
+/// Indicates the current compilation progress.
+///
+/// All fields are kept private for forwards compatibility and future extension.
+/// Use the provided methods to access progress data.
+#[derive(Clone, Debug, Default)]
+pub struct CompilationProgress {
+    phase_name: Option<Cow<'static, str>>,
+    phase_step_count: Option<u64>,
+    phase_step: Option<u64>,
+}
+
+impl CompilationProgress {
+    /// Creates a new [`CompilationProgress`].
+    pub fn new(
+        phase_name: Option<Cow<'static, str>>,
+        phase_step_count: Option<u64>,
+        phase_step: Option<u64>,
+    ) -> Self {
+        Self {
+            phase_name,
+            phase_step_count,
+            phase_step,
+        }
+    }
+
+    /// Returns the name of the phase currently being executed.
+    pub fn phase_name(&self) -> Option<&str> {
+        self.phase_name.as_deref()
+    }
+
+    /// Returns the total number of steps in the current phase, if known.
+    pub fn phase_step_count(&self) -> Option<u64> {
+        self.phase_step_count
+    }
+
+    /// Returns the index of the current step within the phase, if known.
+    pub fn phase_step(&self) -> Option<u64> {
+        self.phase_step
+    }
+}
+
+/// Error returned when the user requests to abort an expensive computation.
+#[derive(Clone, Debug, Error)]
+#[error("{reason}")]
+pub struct UserAbort {
+    reason: String,
+}
+
+impl UserAbort {
+    /// Creates a new [`UserAbort`].
+    pub fn new(reason: impl Into<String>) -> Self {
+        Self {
+            reason: reason.into(),
+        }
+    }
+
+    /// Returns the configured reason.
+    pub fn reason(&self) -> &str {
+        &self.reason
+    }
+}
+
+/// Wraps a boxed callback that can receive compilation progress notifications.
+#[derive(Clone)]
+pub struct CompilationProgressCallback {
+    callback: Arc<dyn Fn(CompilationProgress) -> Result<(), UserAbort> + Send + Sync + 'static>,
+}
+
+impl CompilationProgressCallback {
+    /// Create a new callback wrapper.
+    ///
+    /// The provided callback will be invoked with progress updates during the compilation process,
+    /// and has to return a `Result<(), UserAbort>`.
+    ///
+    /// If the callback returns an error, the compilation will be aborted with a `CompileError::Aborted`.
+    pub fn new<F>(callback: F) -> Self
+    where
+        F: Fn(CompilationProgress) -> Result<(), UserAbort> + Send + Sync + 'static,
+    {
+        Self {
+            callback: Arc::new(callback),
+        }
+    }
+
+    /// Notify the callback about new progress information.
+    pub fn notify(&self, progress: CompilationProgress) -> Result<(), UserAbort> {
+        (self.callback)(progress)
+    }
+}
+
+impl fmt::Debug for CompilationProgressCallback {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("CompilationProgressCallback").finish()
+    }
+}
diff --git a/lib/types/src/serialize.rs b/lib/types/src/serialize.rs
index d98af1dac7..6e80335805 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::{DeserializeError, lib::std::mem};
 
 /// 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 = 12;
 
     /// Magic number to identify wasmer metadata.
     const MAGIC: [u8; 8] = *b"WASMER\0\0";
@@ -238,7 +40,7 @@ impl MetadataHeader {
 
     /// Parses the header and returns the length of the metadata following it.
     pub fn parse(bytes: &[u8]) -> Result<usize, DeserializeError> {
-        if bytes.as_ptr() as usize % 8 != 0 {
+        if !(bytes.as_ptr() as usize).is_multiple_of(8) {
             return Err(DeserializeError::CorruptedBinary(
                 "misaligned metadata".to_string(),
             ));
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 81%
rename from lib/types/src/compilation/target.rs
rename to lib/types/src/target.rs
index 0d3d98f144..c0e4eada1e 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,
@@ -49,7 +48,7 @@ pub enum CpuFeature {
     LZCNT,
     // ARM features
     NEON,
-    // Risc-V features
+    // RISC-V features
 }
 
 impl CpuFeature {
@@ -127,6 +126,11 @@ impl CpuFeature {
         // We default to an empty hash set
         EnumSet::new()
     }
+
+    /// Build a set of all available `CpuFeature`s.
+    pub fn all() -> EnumSet<Self> {
+        EnumSet::all()
+    }
 }
 
 // This options should map exactly the GCC options indicated
@@ -160,26 +164,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 +234,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..2e85a785a8 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,16 @@ 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,
+
+    /// A throw_ref was executed but the exnref was not initialized.
+    UninitializedExnRef = 12,
+
+    /// An async imported function tried to yield when not called
+    /// via `Function::call_async`.
+    YieldOutsideAsyncContext = 13,
 }
 
 impl TrapCode {
@@ -86,6 +87,11 @@ impl TrapCode {
             Self::BadConversionToInteger => "invalid conversion to integer",
             Self::UnreachableCodeReached => "unreachable",
             Self::UnalignedAtomic => "unaligned atomic access",
+            Self::UncaughtException => "uncaught exception",
+            Self::UninitializedExnRef => "uninitialized exnref",
+            Self::YieldOutsideAsyncContext => {
+                "async imported function yielded when not called via `Function::call_async`"
+            }
         }
     }
 }
@@ -104,6 +110,9 @@ impl Display for TrapCode {
             Self::BadConversionToInteger => "bad_toint",
             Self::UnreachableCodeReached => "unreachable",
             Self::UnalignedAtomic => "unalign_atom",
+            Self::UncaughtException => "uncaught_exception",
+            Self::UninitializedExnRef => "uninitialized_exnref",
+            Self::YieldOutsideAsyncContext => "yield_outside_async_context",
         };
         f.write_str(identifier)
     }
@@ -125,6 +134,9 @@ impl FromStr for TrapCode {
             "bad_toint" => Ok(Self::BadConversionToInteger),
             "unreachable" => Ok(Self::UnreachableCodeReached),
             "unalign_atom" => Ok(Self::UnalignedAtomic),
+            "uncaught_exception" => Ok(Self::UncaughtException),
+            "uninitialized_exnref" => Ok(Self::UninitializedExnRef),
+            "yield_outside_async_context" => Ok(Self::YieldOutsideAsyncContext),
             _ => Err(()),
         }
     }
diff --git a/lib/types/src/types.rs b/lib/types/src/types.rs
index 3b9e4af215..b1b122aa07 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
@@ -347,11 +360,7 @@ impl Mutability {
 
 impl From<bool> for Mutability {
     fn from(value: bool) -> Self {
-        if value {
-            Self::Var
-        } else {
-            Self::Const
-        }
+        if value { Self::Var } else { Self::Const }
     }
 }
 
@@ -365,10 +374,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 +419,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 +446,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 +516,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 +558,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/value.rs b/lib/types/src/value.rs
index 045594673a..722d1e6079 100644
--- a/lib/types/src/value.rs
+++ b/lib/types/src/value.rs
@@ -17,6 +17,7 @@ pub union RawValue {
     pub u128: u128,
     pub funcref: usize,
     pub externref: usize,
+    pub exnref: u32,
     pub bytes: [u8; 16],
 }
 
diff --git a/lib/types/src/vmoffsets.rs b/lib/types/src/vmoffsets.rs
index f48176d45e..4b0aa1aa7a 100644
--- a/lib/types/src/vmoffsets.rs
+++ b/lib/types/src/vmoffsets.rs
@@ -12,7 +12,6 @@ use crate::{
 };
 use more_asserts::assert_lt;
 use std::convert::TryFrom;
-use std::mem::size_of;
 
 /// An index type for builtin functions.
 #[derive(Copy, Clone, Debug)]
@@ -136,13 +135,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 `debug_usize` builtin function.
+    pub const fn get_imported_debug_usize_index() -> Self {
+        Self(30)
+    }
+
+    /// Returns an index for wasm's imported `debug_str` builtin function.
+    pub const fn get_imported_debug_str_index() -> Self {
+        Self(31)
+    }
+
+    /// Returns an index for wasm's imported `wasmer_eh_personality2` builtin function.
+    pub const fn get_imported_personality2_index() -> Self {
+        Self(32)
+    }
+
+    /// Returns an index for wasm's imported `alloc_exception` builtin function.
+    pub const fn get_imported_alloc_exception_index() -> Self {
+        Self(33)
+    }
+
+    /// Returns an index for wasm's imported `throw` builtin function.
+    pub const fn get_imported_throw_index() -> Self {
+        Self(34)
+    }
+
+    /// Returns an index for wasm's imported `read_exnref` builtin function.
+    pub const fn get_imported_read_exnref_index() -> Self {
+        Self(35)
+    }
+
+    /// Returns an index for wasm's imported `exception_into_exnref` builtin function.
+    pub const fn get_imported_exception_into_exnref_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 +199,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 +216,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 +231,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 +253,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 +262,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 +289,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 +298,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,
@@ -285,16 +328,17 @@ impl VMOffsets {
             base.checked_add(num_items.checked_mul(item_size).unwrap())
                 .unwrap()
         }
-        /// Offset base by num_items items of size item_size, panicking on overflow
-        /// Also, will align the value on pointer size boundary,
-        /// to avoid misalignement issue
-        fn offset_by_aligned(base: u32, num_items: u32, item_size: u32) -> u32 {
+        // Offset base by num_items items of size item_size, panicking on overflow
+        // Also, will align the value on pointer size boundary,
+        // to avoid misalignement issue
+        let pointer_size = self.pointer_size as u32;
+        let offset_by_aligned = |base: u32, num_items: u32, item_size: u32| -> u32 {
             align(
                 base.checked_add(num_items.checked_mul(item_size).unwrap())
                     .unwrap(),
-                size_of::<&u32>() as u32,
+                pointer_size,
             )
-        }
+        };
 
         self.vmctx_signature_ids_begin = 0;
         self.vmctx_imported_functions_begin = offset_by_aligned(
@@ -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
@@ -785,7 +850,7 @@ mod tests {
     #[test]
     fn alignment() {
         fn is_aligned(x: u32) -> bool {
-            x % 16 == 0
+            x.is_multiple_of(16)
         }
         assert!(is_aligned(align(0, 16)));
         assert!(is_aligned(align(32, 16)));
diff --git a/lib/virtual-fs/Cargo.toml b/lib/virtual-fs/Cargo.toml
index 8b7b41a3cb..05d66ffddf 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.700.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.700.0", default-features = false }
 dashmap.workspace = true
-dunce = "1.0.4"
-anyhow = { version = "1.0.66", optional = true }
-async-trait = { version = "^0.1" }
-bytes = "1"
-derivative = "2.2.0"
-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"
+derive_more.workspace = true
+dunce.workspace = true
+anyhow = { workspace = true, optional = true }
+async-trait.workspace = true
+bytes.workspace = true
+filetime = { workspace = true, optional = true }
+fs_extra = { workspace = true, optional = true }
+futures.workspace = true
+indexmap.workspace = true
 libc = { workspace = true, optional = true }
-pin-project-lite = "0.2.9"
-replace_with = "0.1.7"
-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" }
-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" }
+pin-project-lite.workspace = true
+replace_with.workspace = true
+shared-buffer.workspace = true
+slab.workspace = true
+thiserror.workspace = true
 
-[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-getrandom = { version = "0.2", features = [ "js" ] }
+tokio = { workspace = true, features = [
+	"io-util",
+	"sync",
+	"macros",
+], default-features = false }
+tracing = { workspace = true, default-features = true }
+typetag = { workspace = true, optional = true }
+webc = { workspace = true, optional = true, features = ["v1"] }
+serde = { workspace = true, default-features = false, features = [
+	"derive",
+], optional = true }
+getrandom.workspace = true
+web-time = { workspace = true, 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/arc_fs.rs b/lib/virtual-fs/src/arc_fs.rs
index 4646226cfe..4afaa4c750 100644
--- a/lib/virtual-fs/src/arc_fs.rs
+++ b/lib/virtual-fs/src/arc_fs.rs
@@ -50,7 +50,7 @@ impl FileSystem for ArcFileSystem {
         self.fs.remove_file(path)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         self.fs.new_open_options()
     }
 
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..ab6b2ece65 100644
--- a/lib/virtual-fs/src/builder.rs
+++ b/lib/virtual-fs/src/builder.rs
@@ -9,7 +9,6 @@ use crate::tmp_fs::TmpFileSystem;
 
 pub struct RootFileSystemBuilder {
     default_root_dirs: bool,
-    create_tmp: bool,
     default_dev_files: bool,
     add_wasmer_command: bool,
     stdin: Option<Box<dyn VirtualFile + Send + Sync>>,
@@ -22,7 +21,6 @@ impl Default for RootFileSystemBuilder {
     fn default() -> Self {
         Self {
             default_root_dirs: true,
-            create_tmp: true,
             default_dev_files: true,
             add_wasmer_command: true,
             stdin: None,
@@ -63,24 +61,18 @@ impl RootFileSystemBuilder {
         self
     }
 
-    pub fn with_tmp(mut self, val: bool) -> Self {
-        self.create_tmp = val;
-        self
+    pub fn build(self) -> TmpFileSystem {
+        self.build_ext(&[])
     }
 
-    pub fn build(self) -> TmpFileSystem {
+    pub fn build_ext(self, mapped_dirs: &[&str]) -> TmpFileSystem {
         let tmp = TmpFileSystem::new();
 
         if self.default_root_dirs {
-            let default_dirs = {
-                let mut dirs = vec!["/.app", "/.private", "/bin", "/dev", "/etc"];
-
-                if self.create_tmp {
-                    dirs.push("/tmp");
-                }
-
-                dirs
-            };
+            let default_dirs = ["/.app", "/.private", "/bin", "/dev", "/etc", "/tmp"]
+                .into_iter()
+                .filter(|d| !mapped_dirs.contains(d))
+                .collect::<Vec<_>>();
 
             for root_dir in &default_dirs {
                 if let Err(err) = tmp.create_dir(Path::new(root_dir)) {
@@ -122,6 +114,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 +124,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 +193,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/empty_fs.rs b/lib/virtual-fs/src/empty_fs.rs
index 5c6fd95680..ace8ba70f9 100644
--- a/lib/virtual-fs/src/empty_fs.rs
+++ b/lib/virtual-fs/src/empty_fs.rs
@@ -64,7 +64,7 @@ impl FileSystem for EmptyFileSystem {
         Err(FsError::EntryNotFound)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
 
diff --git a/lib/virtual-fs/src/filesystems.rs b/lib/virtual-fs/src/filesystems.rs
index 46682a49a1..1c9bac053a 100644
--- a/lib/virtual-fs/src/filesystems.rs
+++ b/lib/virtual-fs/src/filesystems.rs
@@ -103,4 +103,6 @@ macro_rules! tuple_filesystems {
     () => {};
 }
 
-tuple_filesystems!(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16,);
+tuple_filesystems!(
+    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16,
+);
diff --git a/lib/virtual-fs/src/host_fs.rs b/lib/virtual-fs/src/host_fs.rs
index 199ee9fb50..e0eb3fbdb3 100644
--- a/lib/virtual-fs/src/host_fs.rs
+++ b/lib/virtual-fs/src/host_fs.rs
@@ -5,7 +5,7 @@ use crate::{
 use bytes::{Buf, Bytes};
 use futures::future::BoxFuture;
 #[cfg(feature = "enable-serde")]
-use serde::{de, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de};
 use std::convert::TryInto;
 use std::fs;
 use std::io::{self, Seek};
@@ -154,7 +154,7 @@ impl crate::FileSystem for FileSystem {
 
     fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
         Box::pin(async move {
-            use filetime::{set_file_mtime, FileTime};
+            use filetime::{FileTime, set_file_mtime};
             let norm_from = normalize_path(from);
             let norm_to = normalize_path(to);
 
@@ -216,7 +216,7 @@ impl crate::FileSystem for FileSystem {
         fs::remove_file(path).map_err(Into::into)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
 
@@ -280,24 +280,15 @@ impl TryInto<Metadata> for std::fs::Metadata {
             },
             accessed: self
                 .accessed()
-                .and_then(|time| {
-                    time.duration_since(UNIX_EPOCH)
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-                })
+                .and_then(|time| time.duration_since(UNIX_EPOCH).map_err(io::Error::other))
                 .map_or(0, |time| time.as_nanos() as u64),
             created: self
                 .created()
-                .and_then(|time| {
-                    time.duration_since(UNIX_EPOCH)
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-                })
+                .and_then(|time| time.duration_since(UNIX_EPOCH).map_err(io::Error::other))
                 .map_or(0, |time| time.as_nanos() as u64),
             modified: self
                 .modified()
-                .and_then(|time| {
-                    time.duration_since(UNIX_EPOCH)
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-                })
+                .and_then(|time| time.duration_since(UNIX_EPOCH).map_err(io::Error::other))
                 .map_or(0, |time| time.as_nanos() as u64),
             len: self.len(),
         })
@@ -351,10 +342,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 +626,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))]
@@ -712,10 +709,7 @@ impl AsyncRead for Stdout {
         _cx: &mut Context<'_>,
         _buf: &mut tokio::io::ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not read from stdout",
-        )))
+        Poll::Ready(Err(io::Error::other("can not read from stdout")))
     }
 }
 
@@ -759,14 +753,11 @@ impl AsyncWrite for Stdout {
 
 impl AsyncSeek for Stdout {
     fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "can not seek stdout"))
+        Err(io::Error::other("can not seek stdout"))
     }
 
     fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not seek stdout",
-        )))
+        Poll::Ready(Err(io::Error::other("can not seek stdout")))
     }
 }
 
@@ -798,10 +789,7 @@ impl AsyncRead for Stderr {
         _cx: &mut Context<'_>,
         _buf: &mut tokio::io::ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not read from stderr",
-        )))
+        Poll::Ready(Err(io::Error::other("can not read from stderr")))
     }
 }
 
@@ -845,14 +833,11 @@ impl AsyncWrite for Stderr {
 
 impl AsyncSeek for Stderr {
     fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "can not seek stderr"))
+        Err(io::Error::other("can not seek stderr"))
     }
 
     fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not seek stderr",
-        )))
+        Poll::Ready(Err(io::Error::other("can not seek stderr")))
     }
 }
 
@@ -952,24 +937,15 @@ impl AsyncWrite for Stdin {
         _cx: &mut Context<'_>,
         _buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not wrote to stdin",
-        )))
+        Poll::Ready(Err(io::Error::other("can not wrote to stdin")))
     }
 
     fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not flush stdin",
-        )))
+        Poll::Ready(Err(io::Error::other("can not flush stdin")))
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not wrote to stdin",
-        )))
+        Poll::Ready(Err(io::Error::other("can not wrote to stdin")))
     }
 
     fn poll_write_vectored(
@@ -977,23 +953,17 @@ impl AsyncWrite for Stdin {
         _cx: &mut Context<'_>,
         _bufs: &[io::IoSlice<'_>],
     ) -> Poll<io::Result<usize>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not wrote to stdin",
-        )))
+        Poll::Ready(Err(io::Error::other("can not wrote to stdin")))
     }
 }
 
 impl AsyncSeek for Stdin {
     fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
-        Err(io::Error::new(io::ErrorKind::Other, "can not seek stdin"))
+        Err(io::Error::other("can not seek stdin"))
     }
 
     fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not seek stdin",
-        )))
+        Poll::Ready(Err(io::Error::other("can not seek stdin")))
     }
 }
 
@@ -1109,7 +1079,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 +1240,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 +1257,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 +1451,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..5a9d35f99c 100644
--- a/lib/virtual-fs/src/lib.rs
+++ b/lib/virtual-fs/src/lib.rs
@@ -1,10 +1,11 @@
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(test)]
 #[macro_use]
 extern crate pretty_assertions;
 
 use futures::future::BoxFuture;
+use shared_buffer::OwnedBuffer;
 use std::any::Any;
 use std::ffi::OsString;
 use std::fmt;
@@ -82,7 +83,7 @@ pub use tokio::io::{AsyncWrite, AsyncWriteExt};
 
 pub trait ClonableVirtualFile: VirtualFile + Clone {}
 
-pub use ops::{copy_reference, copy_reference_ext, create_dir_all};
+pub use ops::{copy_reference, copy_reference_ext, create_dir_all, walk};
 
 pub trait FileSystem: fmt::Debug + Send + Sync + 'static + Upcastable {
     fn readlink(&self, path: &Path) -> Result<PathBuf>;
@@ -97,10 +98,10 @@ pub trait FileSystem: fmt::Debug + Send + Sync + 'static + Upcastable {
     fn symlink_metadata(&self, path: &Path) -> Result<Metadata>;
     fn remove_file(&self, path: &Path) -> Result<()>;
 
-    fn new_open_options(&self) -> OpenOptions;
+    fn new_open_options(&self) -> OpenOptions<'_>;
 
     fn mount(&self, name: String, path: &Path, fs: Box<dyn FileSystem + Send + Sync>)
-        -> Result<()>;
+    -> Result<()>;
 }
 
 impl dyn FileSystem + 'static {
@@ -152,7 +153,7 @@ where
         (**self).remove_file(path)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         (**self).new_open_options()
     }
 
@@ -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/limiter.rs b/lib/virtual-fs/src/limiter.rs
index bcd44ee676..2fc40d531d 100644
--- a/lib/virtual-fs/src/limiter.rs
+++ b/lib/virtual-fs/src/limiter.rs
@@ -4,7 +4,7 @@ use crate::FsError;
 
 pub use self::tracked_vec::TrackedVec;
 
-/// Allows tracking and limiting the memory usage of a memfs [`FileSystem`].
+/// Allows tracking and limiting the memory usage of a memfs [`FileSystem`](crate::FileSystem).
 pub trait FsMemoryLimiter: Send + Sync + std::fmt::Debug {
     fn on_grow(&self, grown_bytes: usize) -> std::result::Result<(), FsError>;
     fn on_shrink(&self, shrunk_bytes: usize);
diff --git a/lib/virtual-fs/src/mem_fs/file.rs b/lib/virtual-fs/src/mem_fs/file.rs
index 3c0f3837b4..316b978bc3 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(
@@ -353,10 +385,11 @@ impl VirtualFile for FileHandle {
             )));
         }
 
-        let mut fs =
-            self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+        let mut fs = self
+            .filesystem
+            .inner
+            .write()
+            .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
         let inode = fs.storage.get_mut(self.inode);
         match inode {
@@ -408,10 +441,11 @@ impl VirtualFile for FileHandle {
             )));
         }
 
-        let mut fs =
-            self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+        let mut fs = self
+            .filesystem
+            .inner
+            .write()
+            .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
         let inode = fs.storage.get_mut(self.inode);
         match inode {
@@ -456,9 +490,11 @@ impl VirtualFile for FileHandle {
 
         let mut cursor = self.cursor;
         {
-            let mut fs = self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+            let mut fs = self
+                .filesystem
+                .inner
+                .write()
+                .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
             let inode = fs.storage.get_mut(self.inode);
             match inode {
@@ -475,11 +511,22 @@ 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)]
 mod test_virtual_file {
-    use crate::{mem_fs::*, FileSystem as FS};
+    use crate::{FileSystem as FS, mem_fs::*};
     use std::thread::sleep;
     use std::time::Duration;
 
@@ -672,16 +719,22 @@ impl AsyncRead for FileHandle {
 
         let mut cursor = self.cursor;
         let ret = {
-            let mut fs = self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+            let mut fs = self
+                .filesystem
+                .inner
+                .write()
+                .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
             let inode = fs.storage.get_mut(self.inode);
             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 +744,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 +759,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) };
@@ -727,7 +788,7 @@ impl AsyncRead for FileHandle {
                             return Poll::Ready(Err(io::Error::new(
                                 io::ErrorKind::NotFound,
                                 format!("inode `{}` doesn't match a file", self.inode),
-                            )))
+                            )));
                         }
                     }
                 }
@@ -752,9 +813,11 @@ impl AsyncSeek for FileHandle {
 
         let mut cursor = self.cursor;
         let ret = {
-            let mut fs = self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+            let mut fs = self
+                .filesystem
+                .inner
+                .write()
+                .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
             let inode = fs.storage.get_mut(self.inode);
             match inode {
@@ -821,10 +884,11 @@ impl AsyncSeek for FileHandle {
             return Poll::Ready(Ok(0));
         }
 
-        let mut fs =
-            self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+        let mut fs = self
+            .filesystem
+            .inner
+            .write()
+            .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
         let inode = fs.storage.get_mut(self.inode);
         match inode {
@@ -875,9 +939,11 @@ impl AsyncWrite for FileHandle {
 
         let mut cursor = self.cursor;
         let bytes_written = {
-            let mut fs = self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+            let mut fs = self
+                .filesystem
+                .inner
+                .write()
+                .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
             let inode = fs.storage.get_mut(self.inode);
             match inode {
@@ -928,7 +994,7 @@ impl AsyncWrite for FileHandle {
                             return Poll::Ready(Err(io::Error::new(
                                 io::ErrorKind::NotFound,
                                 format!("inode `{}` doesn't match a file", self.inode),
-                            )))
+                            )));
                         }
                     }
                 }
@@ -936,7 +1002,7 @@ impl AsyncWrite for FileHandle {
                     return Poll::Ready(Err(io::Error::new(
                         io::ErrorKind::NotFound,
                         format!("inode `{}` doesn't match a file", self.inode),
-                    )))
+                    )));
                 }
             }
         };
@@ -951,9 +1017,11 @@ impl AsyncWrite for FileHandle {
     ) -> Poll<io::Result<usize>> {
         let mut cursor = self.cursor;
         let ret = {
-            let mut fs = self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+            let mut fs = self
+                .filesystem
+                .inner
+                .write()
+                .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
             let inode = fs.storage.get_mut(self.inode);
             match inode {
@@ -1013,10 +1081,11 @@ impl AsyncWrite for FileHandle {
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        let mut fs =
-            self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+        let mut fs = self
+            .filesystem
+            .inner
+            .write()
+            .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
         let inode = fs.storage.get_mut(self.inode);
         match inode {
@@ -1049,10 +1118,11 @@ impl AsyncWrite for FileHandle {
     }
 
     fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        let mut fs =
-            self.filesystem.inner.write().map_err(|_| {
-                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
-            })?;
+        let mut fs = self
+            .filesystem
+            .inner
+            .write()
+            .map_err(|_| io::Error::other("failed to acquire a write lock"))?;
 
         let inode = fs.storage.get_mut(self.inode);
         match inode {
@@ -1115,7 +1185,7 @@ impl AsyncWrite for FileHandle {
 mod test_read_write_seek {
     use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
 
-    use crate::{mem_fs::*, FileSystem as FS};
+    use crate::{FileSystem as FS, mem_fs::*};
     use std::io;
 
     macro_rules! path {
@@ -1511,11 +1581,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..91544d07f6 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)?;
 
@@ -502,22 +502,25 @@ impl crate::FileOpener for FileSystem {
                 let inode_of_file = fs.storage.vacant_entry().key();
 
                 // We might be in optimized mode
-                let file = if let Some(offload) = fs.backing_offload.clone() {
-                    let file = OffloadedFile::new(fs.limiter.clone(), offload);
-                    Node::OffloadedFile(OffloadedFileNode {
-                        inode: inode_of_file,
-                        name: name_of_file,
-                        file,
-                        metadata,
-                    })
-                } else {
-                    let file = File::new(fs.limiter.clone());
-                    Node::File(FileNode {
-                        inode: inode_of_file,
-                        name: name_of_file,
-                        file,
-                        metadata,
-                    })
+                let file = match fs.backing_offload.clone() {
+                    Some(offload) => {
+                        let file = OffloadedFile::new(fs.limiter.clone(), offload);
+                        Node::OffloadedFile(OffloadedFileNode {
+                            inode: inode_of_file,
+                            name: name_of_file,
+                            file,
+                            metadata,
+                        })
+                    }
+                    _ => {
+                        let file = File::new(fs.limiter.clone());
+                        Node::File(FileNode {
+                            inode: inode_of_file,
+                            name: name_of_file,
+                            file,
+                            metadata,
+                        })
+                    }
                 };
 
                 // Creating the file in the storage.
@@ -554,7 +557,7 @@ impl crate::FileOpener for FileSystem {
 mod test_file_opener {
     use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
 
-    use crate::{mem_fs::*, FileSystem as FS, FsError};
+    use crate::{FileSystem as FS, FsError, mem_fs::*};
     use std::io;
 
     macro_rules! path {
diff --git a/lib/virtual-fs/src/mem_fs/filesystem.rs b/lib/virtual-fs/src/mem_fs/filesystem.rs
index 65b34ce542..17ec611ce9 100644
--- a/lib/virtual-fs/src/mem_fs/filesystem.rs
+++ b/lib/virtual-fs/src/mem_fs/filesystem.rs
@@ -273,12 +273,21 @@ impl crate::FileSystem for FileSystem {
         // Read lock.
         let guard = self.inner.read().map_err(|_| FsError::Lock)?;
 
+        fn rebase_entries(entries: &mut ReadDir, base: &Path) {
+            for entry in &mut entries.data {
+                let name = entry.file_name();
+                entry.path = base.join(name);
+            }
+        }
+
         // Canonicalize the path.
-        let (path, inode_of_directory) = guard.canonicalize(path)?;
+        let (guest_path, inode_of_directory) = guard.canonicalize(path)?;
         let inode_of_directory = match inode_of_directory {
             InodeResolution::Found(a) => a,
-            InodeResolution::Redirect(fs, path) => {
-                return fs.read_dir(path.as_path());
+            InodeResolution::Redirect(fs, redirect_path) => {
+                let mut entries = fs.read_dir(redirect_path.as_path())?;
+                rebase_entries(&mut entries, &guest_path);
+                return Ok(entries);
             }
         };
 
@@ -299,8 +308,12 @@ impl crate::FileSystem for FileSystem {
                 })
                 .collect(),
 
-            Some(Node::ArcDirectory(ArcDirectoryNode { fs, path, .. })) => {
-                return fs.read_dir(path.as_path());
+            Some(Node::ArcDirectory(ArcDirectoryNode {
+                fs, path: fs_path, ..
+            })) => {
+                let mut entries = fs.read_dir(fs_path.as_path())?;
+                rebase_entries(&mut entries, &guest_path);
+                return Ok(entries);
             }
 
             _ => return Err(FsError::InvalidInput),
@@ -447,7 +460,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 +506,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 +586,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),
             }
         })
     }
@@ -677,7 +709,7 @@ impl crate::FileSystem for FileSystem {
         Ok(())
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
 
@@ -1132,11 +1164,12 @@ impl DirectoryMustBeEmpty {
 
 #[cfg(test)]
 mod test_filesystem {
-    use std::{borrow::Cow, path::Path};
+    use std::{path::Path, sync::Arc};
 
+    use shared_buffer::OwnedBuffer;
     use tokio::io::AsyncReadExt;
 
-    use crate::{mem_fs::*, ops, DirEntry, FileSystem as FS, FileType, FsError};
+    use crate::{DirEntry, FileSystem as FS, FileType, FsError, mem_fs::*, ops};
 
     macro_rules! path {
         ($path:expr) => {
@@ -1178,7 +1211,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 +1314,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 +1343,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();
@@ -1749,7 +1782,7 @@ mod test_filesystem {
                     path,
                     metadata: Ok(Metadata { ft, .. }),
                 }))
-                    if path == path!(buf "/foo") && ft.is_dir()
+                    if path.as_path() == path!("/foo") && ft.is_dir()
             ),
             "checking entry #1",
         );
@@ -1760,7 +1793,7 @@ mod test_filesystem {
                     path,
                     metadata: Ok(Metadata { ft, .. }),
                 }))
-                    if path == path!(buf "/bar") && ft.is_dir()
+                    if path.as_path() == path!("/bar") && ft.is_dir()
             ),
             "checking entry #2",
         );
@@ -1771,7 +1804,7 @@ mod test_filesystem {
                     path,
                     metadata: Ok(Metadata { ft, .. }),
                 }))
-                    if path == path!(buf "/baz") && ft.is_dir()
+                    if path.as_path() == path!("/baz") && ft.is_dir()
             ),
             "checking entry #3",
         );
@@ -1782,7 +1815,7 @@ mod test_filesystem {
                     path,
                     metadata: Ok(Metadata { ft, .. }),
                 }))
-                    if path == path!(buf "/a.txt") && ft.is_file()
+                    if path.as_path() == path!("/a.txt") && ft.is_file()
             ),
             "checking entry #4",
         );
@@ -1793,7 +1826,7 @@ mod test_filesystem {
                     path,
                     metadata: Ok(Metadata { ft, .. }),
                 }))
-                    if path == path!(buf "/b.txt") && ft.is_file()
+                    if path.as_path() == path!("/b.txt") && ft.is_file()
             ),
             "checking entry #5",
         );
@@ -1916,6 +1949,24 @@ mod test_filesystem {
         assert!(ops::is_file(&fs, "/top-level/nested/another-file.txt"));
     }
 
+    #[tokio::test]
+    async fn read_dir_rebases_mount_paths() {
+        let mounted = FileSystem::default();
+        ops::touch(&mounted, "/file.txt").unwrap();
+        let mounted: Arc<dyn crate::FileSystem + Send + Sync> = Arc::new(mounted);
+
+        let fs = FileSystem::default();
+        fs.mount("/mnt".into(), &mounted, "/".into()).unwrap();
+
+        let entries: Vec<_> = fs
+            .read_dir(Path::new("/mnt"))
+            .unwrap()
+            .map(|e| e.unwrap().path)
+            .collect();
+
+        assert_eq!(entries, vec![Path::new("/mnt/file.txt").to_path_buf()]);
+    }
+
     #[tokio::test]
     async fn test_merge_flat() {
         let main = FileSystem::default();
@@ -1923,13 +1974,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..e9b268fc02 100644
--- a/lib/virtual-fs/src/mem_fs/offloaded_file.rs
+++ b/lib/virtual-fs/src/mem_fs/offloaded_file.rs
@@ -71,8 +71,7 @@ impl OffloadBackingStoreState {
                     return Err(io::ErrorKind::UnexpectedEof.into());
                 }
             };
-            self.mmap_offload = OwnedBuffer::from_file(mmap_file)
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+            self.mmap_offload = OwnedBuffer::from_file(mmap_file).map_err(io::Error::other)?;
             if end > self.mmap_offload.len() as u64 {
                 tracing::trace!(
                     "mmap buffer out of bounds {} vs {} for {:?}",
@@ -136,7 +135,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,
@@ -401,25 +400,22 @@ mod tests {
     #[test]
     #[tracing_test::traced_test]
     pub fn test_offload_file() -> anyhow::Result<()> {
-        let buffer = OwnedBuffer::from_bytes(std::iter::repeat(12u8).take(100).collect::<Vec<_>>());
+        let buffer = OwnedBuffer::from_bytes(std::iter::repeat_n(12u8, 100).collect::<Vec<_>>());
         let test_data2 = buffer.clone();
 
         let backing = OffloadBackingStore::new(buffer, None);
         let mut file = OffloadedFile::new(None, backing);
 
         let mut cursor = 0u64;
-        let test_data = std::iter::repeat(56u8).take(100).collect::<Vec<_>>();
+        let test_data = std::iter::repeat_n(56u8, 100).collect::<Vec<_>>();
         file.write(OffloadWrite::Buffer(&test_data), &mut cursor)?;
 
         assert_eq!(file.len(), 100);
 
         cursor = 0;
-        let mut result = std::iter::repeat(0u8).take(100).collect::<Vec<_>>();
+        let mut result = std::iter::repeat_n(0u8, 100).collect::<Vec<_>>();
         file.read(&mut result, &mut cursor)?;
-        assert_eq!(
-            &result,
-            &std::iter::repeat(56u8).take(100).collect::<Vec<_>>()
-        );
+        assert_eq!(&result, &std::iter::repeat_n(56u8, 100).collect::<Vec<_>>());
 
         cursor = 50;
         file.write(OffloadWrite::Buffer(&test_data2), &mut cursor)?;
@@ -427,13 +423,12 @@ mod tests {
         assert_eq!(file.len(), 150);
 
         cursor = 0;
-        let mut result = std::iter::repeat(0u8).take(150).collect::<Vec<_>>();
+        let mut result = std::iter::repeat_n(0u8, 150).collect::<Vec<_>>();
         file.read(&mut result, &mut cursor)?;
         assert_eq!(
             &result,
-            &std::iter::repeat(56u8)
-                .take(50)
-                .chain(std::iter::repeat(12u8).take(100))
+            &std::iter::repeat_n(56u8, 50)
+                .chain(std::iter::repeat_n(12u8, 100))
                 .collect::<Vec<_>>()
         );
 
@@ -441,42 +436,37 @@ mod tests {
         assert_eq!(file.len(), 200);
 
         cursor = 0;
-        let mut result = std::iter::repeat(0u8).take(200).collect::<Vec<_>>();
+        let mut result = std::iter::repeat_n(0u8, 200).collect::<Vec<_>>();
         file.read(&mut result, &mut cursor)?;
         assert_eq!(
             &result,
-            &std::iter::repeat(56u8)
-                .take(50)
-                .chain(std::iter::repeat(12u8).take(100))
-                .chain(std::iter::repeat(99u8).take(50))
+            &std::iter::repeat_n(56u8, 50)
+                .chain(std::iter::repeat_n(12u8, 100))
+                .chain(std::iter::repeat_n(99u8, 50))
                 .collect::<Vec<_>>()
         );
 
         file.resize(33, 1u8);
 
         cursor = 0;
-        let mut result = std::iter::repeat(0u8).take(33).collect::<Vec<_>>();
+        let mut result = std::iter::repeat_n(0u8, 33).collect::<Vec<_>>();
         file.read(&mut result, &mut cursor)?;
-        assert_eq!(
-            &result,
-            &std::iter::repeat(56u8).take(33).collect::<Vec<_>>()
-        );
+        assert_eq!(&result, &std::iter::repeat_n(56u8, 33).collect::<Vec<_>>());
 
         let mut cursor = 10u64;
-        let test_data = std::iter::repeat(74u8).take(10).collect::<Vec<_>>();
+        let test_data = std::iter::repeat_n(74u8, 10).collect::<Vec<_>>();
         file.write(OffloadWrite::Buffer(&test_data), &mut cursor)?;
 
         assert_eq!(file.len(), 33);
 
         cursor = 0;
-        let mut result = std::iter::repeat(0u8).take(33).collect::<Vec<_>>();
+        let mut result = std::iter::repeat_n(0u8, 33).collect::<Vec<_>>();
         file.read(&mut result, &mut cursor)?;
         assert_eq!(
             &result,
-            &std::iter::repeat(56u8)
-                .take(10)
-                .chain(std::iter::repeat(74u8).take(10))
-                .chain(std::iter::repeat(56u8).take(13))
+            &std::iter::repeat_n(56u8, 10)
+                .chain(std::iter::repeat_n(74u8, 10))
+                .chain(std::iter::repeat_n(56u8, 13))
                 .collect::<Vec<_>>()
         );
 
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/ops.rs b/lib/virtual-fs/src/ops.rs
index 88c9c06680..f0439f47be 100644
--- a/lib/virtual-fs/src/ops.rs
+++ b/lib/virtual-fs/src/ops.rs
@@ -119,12 +119,12 @@ where
 
 /// Returns true if the path is a whiteout file
 pub fn is_white_out(path: impl AsRef<Path>) -> Option<PathBuf> {
-    if let Some(filename) = path.as_ref().file_name() {
-        if let Some(filename) = filename.to_string_lossy().strip_prefix(WHITEOUT_PREFIX) {
-            let mut path = path.as_ref().to_owned();
-            path.set_file_name(filename);
-            return Some(path);
-        }
+    if let Some(filename) = path.as_ref().file_name()
+        && let Some(filename) = filename.to_string_lossy().strip_prefix(WHITEOUT_PREFIX)
+    {
+        let mut path = path.as_ref().to_owned();
+        path.set_file_name(filename);
+        return Some(path);
     }
     None
 }
diff --git a/lib/virtual-fs/src/overlay_fs.rs b/lib/virtual-fs/src/overlay_fs.rs
index 90c1803ece..6f6734df3c 100644
--- a/lib/virtual-fs/src/overlay_fs.rs
+++ b/lib/virtual-fs/src/overlay_fs.rs
@@ -13,8 +13,8 @@ use replace_with::replace_with_or_abort;
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
 
 use crate::{
-    ops, FileOpener, FileSystem, FileSystems, FsError, Metadata, OpenOptions, OpenOptionsConfig,
-    ReadDir, VirtualFile,
+    FileOpener, FileSystem, FileSystems, FsError, Metadata, OpenOptions, OpenOptionsConfig,
+    ReadDir, VirtualFile, ops,
 };
 
 /// A primary filesystem and chain of secondary filesystems that are overlayed
@@ -210,10 +210,10 @@ where
         // Make sure the parent tree is in place on the primary, this is to cover the
         // scenario where the secondaries has a parent structure that is not yet in the
         // primary and the primary needs it to create a sub-directory
-        if let Some(parent) = path.parent() {
-            if self.read_dir(parent).is_ok() {
-                ops::create_dir_all(&self.primary, parent).ok();
-            }
+        if let Some(parent) = path.parent()
+            && self.read_dir(parent).is_ok()
+        {
+            ops::create_dir_all(&self.primary, parent).ok();
         }
 
         // Create the directory in the primary
@@ -526,10 +526,10 @@ where
         // If we are creating the file then do so
         if conf.create {
             // Create the parent structure and remove any whiteouts
-            if let Some(parent) = path.parent() {
-                if ops::exists(self, parent) {
-                    ops::create_dir_all(&self.primary, parent)?;
-                }
+            if let Some(parent) = path.parent()
+                && ops::exists(self, parent)
+            {
+                ops::create_dir_all(&self.primary, parent)?;
             }
             ops::remove_white_out(&self.primary, path);
 
@@ -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>,
         {
@@ -1120,9 +1131,44 @@ mod tests {
     use std::path::PathBuf;
 
     use super::*;
-    use crate::mem_fs::FileSystem as MemFS;
+    use crate::{TmpFileSystem, mem_fs::FileSystem as MemFS};
     use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
 
+    #[test]
+    fn overlay_read_dir_rebases_mounted_entries() {
+        let primary = TmpFileSystem::new();
+        ops::create_dir_all(&primary, "/app").unwrap();
+
+        let volume = MemFS::default();
+        ops::create_dir_all(&volume, "/themes/twentytwentyfour").unwrap();
+
+        let container = MemFS::default();
+        ops::create_dir_all(&container, "/app/wp-content/themes/twentytwentyfour").unwrap();
+
+        let volume: Arc<dyn FileSystem + Send + Sync> = Arc::new(volume);
+        primary
+            .mount(
+                PathBuf::from("/app/wp-content"),
+                &volume,
+                PathBuf::from("/"),
+            )
+            .unwrap();
+
+        let overlay = OverlayFileSystem::new(primary, [container]);
+
+        let mut entries: Vec<_> = overlay
+            .read_dir(Path::new("/app/wp-content/themes"))
+            .unwrap()
+            .map(|entry| entry.unwrap().path)
+            .collect();
+        entries.sort();
+
+        assert_eq!(
+            entries,
+            vec![PathBuf::from("/app/wp-content/themes/twentytwentyfour")],
+        );
+    }
+
     #[tokio::test]
     async fn remove_directory() {
         let primary = MemFS::default();
@@ -1285,7 +1331,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 +1584,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/passthru_fs.rs b/lib/virtual-fs/src/passthru_fs.rs
index 0164d6c9e8..f377c3eab1 100644
--- a/lib/virtual-fs/src/passthru_fs.rs
+++ b/lib/virtual-fs/src/passthru_fs.rs
@@ -2,17 +2,24 @@
 //! needed so that a `Box<dyn VirtualFileSystem>` can be wrapped in an Arc and
 //! shared - some of the interfaces pass around a `Box<dyn VirtualFileSystem>`
 
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
 use crate::*;
 
 #[derive(Debug)]
 pub struct PassthruFileSystem {
-    fs: Box<dyn FileSystem + Send + Sync + 'static>,
+    fs: Arc<dyn FileSystem + Send + Sync + 'static>,
 }
 
 impl PassthruFileSystem {
+    /// Creates a new PassthruFileSystem that wraps the given FileSystem.
+    // NOTE: only kept for backwards compatibility.
+    // TODO: change to only accept Arc, and remove Self::new_arc in the next breaking API change!
     pub fn new(inner: Box<dyn FileSystem + Send + Sync + 'static>) -> Self {
+        Self { fs: inner.into() }
+    }
+
+    pub fn new_arc(inner: Arc<dyn FileSystem + Send + Sync + 'static>) -> Self {
         Self { fs: inner }
     }
 }
@@ -50,7 +57,7 @@ impl FileSystem for PassthruFileSystem {
         self.fs.remove_file(path)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         self.fs.new_open_options()
     }
 
@@ -66,6 +73,8 @@ impl FileSystem for PassthruFileSystem {
 
 #[cfg(test)]
 mod test_builder {
+    use std::sync::Arc;
+
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
     use crate::{FileSystem, PassthruFileSystem};
@@ -96,7 +105,7 @@ mod test_builder {
             .unwrap();
         assert_eq!(buf, b"hello");
 
-        let passthru_fs = PassthruFileSystem::new(Box::new(mem_fs.clone()));
+        let passthru_fs = PassthruFileSystem::new_arc(Arc::new(mem_fs.clone()));
         let mut buf = Vec::new();
         passthru_fs
             .new_open_options()
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/static_fs.rs b/lib/virtual-fs/src/static_fs.rs
index 10e303edc0..66b1e96976 100644
--- a/lib/virtual-fs/src/static_fs.rs
+++ b/lib/virtual-fs/src/static_fs.rs
@@ -209,12 +209,11 @@ impl AsyncSeek for WebCFile {
 
 fn get_volume_name_opt<P: AsRef<Path>>(path: P) -> Option<String> {
     use std::path::Component::Normal;
-    if let Some(Normal(n)) = path.as_ref().components().next() {
-        if let Some(s) = n.to_str() {
-            if s.ends_with(':') {
-                return Some(s.replace(':', ""));
-            }
-        }
+    if let Some(Normal(n)) = path.as_ref().components().next()
+        && let Some(s) = n.to_str()
+        && s.ends_with(':')
+    {
+        return Some(s.replace(':', ""));
     }
     None
 }
@@ -274,8 +273,7 @@ impl FileSystem for StaticFileSystem {
     }
     fn create_dir(&self, path: &Path) -> Result<(), FsError> {
         let path = normalizes_path(path);
-        let result = self.memory.create_dir(Path::new(&path));
-        result
+        self.memory.create_dir(Path::new(&path))
     }
     fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
         let path = normalizes_path(path);
@@ -348,7 +346,7 @@ impl FileSystem for StaticFileSystem {
             result
         }
     }
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
     fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
diff --git a/lib/virtual-fs/src/tmp_fs.rs b/lib/virtual-fs/src/tmp_fs.rs
index f16036bf29..259786a0b6 100644
--- a/lib/virtual-fs/src/tmp_fs.rs
+++ b/lib/virtual-fs/src/tmp_fs.rs
@@ -8,8 +8,8 @@ use std::{
 };
 
 use crate::{
-    limiter::DynFsMemoryLimiter, mem_fs, BoxFuture, FileSystem, Metadata, OpenOptions, ReadDir,
-    Result,
+    BoxFuture, FileSystem, Metadata, OpenOptions, ReadDir, Result, limiter::DynFsMemoryLimiter,
+    mem_fs,
 };
 
 #[derive(Debug, Default, Clone)]
@@ -93,7 +93,7 @@ impl FileSystem for TmpFileSystem {
         self.fs.remove_file(path)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         self.fs.new_open_options()
     }
 
diff --git a/lib/virtual-fs/src/trace_fs.rs b/lib/virtual-fs/src/trace_fs.rs
index ca132bd233..143e835600 100644
--- a/lib/virtual-fs/src/trace_fs.rs
+++ b/lib/virtual-fs/src/trace_fs.rs
@@ -84,7 +84,7 @@ where
     }
 
     #[tracing::instrument(level = "trace", skip(self))]
-    fn new_open_options(&self) -> crate::OpenOptions {
+    fn new_open_options(&self) -> crate::OpenOptions<'_> {
         crate::OpenOptions::new(self)
     }
 
diff --git a/lib/virtual-fs/src/union_fs.rs b/lib/virtual-fs/src/union_fs.rs
index 88d56ad061..b3b815b56c 100644
--- a/lib/virtual-fs/src/union_fs.rs
+++ b/lib/virtual-fs/src/union_fs.rs
@@ -8,7 +8,7 @@ use crate::*;
 
 use std::{path::Path, sync::Arc};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct MountPoint {
     pub path: PathBuf,
     pub name: String,
@@ -36,6 +36,17 @@ pub struct UnionFileSystem {
     pub mounts: DashMap<PathBuf, MountPoint>,
 }
 
+/// Defines how to handle conflicts when merging two UnionFileSystems
+#[derive(Clone, Copy, Debug)]
+pub enum UnionMergeMode {
+    /// Replace existing nodes with the new ones.
+    Replace,
+    /// Skip conflicting nodes, and keep the existing ones.
+    Skip,
+    /// Return an error if a conflict is found.
+    Fail,
+}
+
 impl UnionFileSystem {
     pub fn new() -> Self {
         Self::default()
@@ -58,6 +69,47 @@ impl UnionFileSystem {
                 .to_owned()
         }
     }
+
+    /// Merge another UnionFileSystem into this one.
+    pub fn merge(&self, other: &UnionFileSystem, mode: UnionMergeMode) -> Result<()> {
+        for item in other.mounts.iter() {
+            if self.mounts.contains_key(item.key()) {
+                match mode {
+                    UnionMergeMode::Replace => {
+                        self.mounts.insert(item.key().clone(), item.value().clone());
+                    }
+                    UnionMergeMode::Skip => {
+                        tracing::debug!(
+                            path = %item.key().display(),
+                            "skipping existing mount point while merging two union file systems"
+                        );
+                    }
+                    UnionMergeMode::Fail => {
+                        return Err(FsError::AlreadyExists);
+                    }
+                }
+            } else {
+                self.mounts.insert(item.key().clone(), item.value().clone());
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Duplicate this UnionFileSystem.
+    ///
+    /// This differs from the Clone implementation in that it creates a new
+    /// underlying shared map.
+    /// Clone just does a shallow copy.
+    pub fn duplicate(&self) -> Self {
+        let mounts = DashMap::new();
+
+        for item in self.mounts.iter() {
+            mounts.insert(item.key().clone(), item.value().clone());
+        }
+
+        Self { mounts }
+    }
 }
 
 impl UnionFileSystem {
@@ -92,10 +144,11 @@ impl FileSystem for UnionFileSystem {
 
         if path.as_os_str().is_empty() {
             Err(FsError::NotAFile)
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            fs.readlink(&path)
         } else {
-            Err(FsError::EntryNotFound)
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => fs.readlink(&path),
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
 
@@ -119,17 +172,20 @@ impl FileSystem for UnionFileSystem {
                 .collect::<Vec<_>>();
 
             Ok(ReadDir::new(entries))
-        } else if let Some((prefix, path, fs)) = self.find_mount(path.to_owned()) {
-            let mut entries = fs.read_dir(&path)?;
+        } else {
+            match self.find_mount(path.to_owned()) {
+                Some((prefix, path, fs)) => {
+                    let mut entries = fs.read_dir(&path)?;
 
-            for entry in &mut entries.data {
-                let path: PathBuf = entry.path.components().skip(1).collect();
-                entry.path = PathBuf::from("/").join(PathBuf::from(&prefix).join(path));
-            }
+                    for entry in &mut entries.data {
+                        let path: PathBuf = entry.path.components().skip(1).collect();
+                        entry.path = PathBuf::from("/").join(PathBuf::from(&prefix).join(path));
+                    }
 
-            Ok(entries)
-        } else {
-            Err(FsError::EntryNotFound)
+                    Ok(entries)
+                }
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
 
@@ -138,18 +194,21 @@ impl FileSystem for UnionFileSystem {
 
         if path.as_os_str().is_empty() {
             Ok(())
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            let result = fs.create_dir(&path);
+        } else {
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => {
+                    let result = fs.create_dir(&path);
 
-            if let Err(e) = result {
-                if e == FsError::AlreadyExists {
-                    return Ok(());
+                    if let Err(e) = result
+                        && e == FsError::AlreadyExists
+                    {
+                        return Ok(());
+                    }
+
+                    result
                 }
+                _ => Err(FsError::EntryNotFound),
             }
-
-            result
-        } else {
-            Err(FsError::EntryNotFound)
         }
     }
     fn remove_dir(&self, path: &Path) -> Result<()> {
@@ -157,10 +216,11 @@ impl FileSystem for UnionFileSystem {
 
         if path.as_os_str().is_empty() {
             Err(FsError::PermissionDenied)
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            fs.remove_dir(&path)
         } else {
-            Err(FsError::EntryNotFound)
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => fs.remove_dir(&path),
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
     fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
@@ -170,14 +230,17 @@ impl FileSystem for UnionFileSystem {
 
             if from.as_os_str().is_empty() {
                 Err(FsError::PermissionDenied)
-            } else if let Some((prefix, path, fs)) = self.find_mount(from.to_owned()) {
-                let to = to.strip_prefix(prefix).map_err(|_| FsError::InvalidInput)?;
+            } else {
+                match self.find_mount(from.to_owned()) {
+                    Some((prefix, path, fs)) => {
+                        let to = to.strip_prefix(prefix).map_err(|_| FsError::InvalidInput)?;
 
-                let to = PathBuf::from("/").join(to);
+                        let to = PathBuf::from("/").join(to);
 
-                fs.rename(&path, &to).await
-            } else {
-                Err(FsError::EntryNotFound)
+                        fs.rename(&path, &to).await
+                    }
+                    _ => Err(FsError::EntryNotFound),
+                }
             }
         })
     }
@@ -192,10 +255,11 @@ impl FileSystem for UnionFileSystem {
                 modified: 0,
                 len: 0,
             })
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            fs.metadata(&path)
         } else {
-            Err(FsError::EntryNotFound)
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => fs.metadata(&path),
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
     fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
@@ -209,10 +273,11 @@ impl FileSystem for UnionFileSystem {
                 modified: 0,
                 len: 0,
             })
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            fs.symlink_metadata(&path)
         } else {
-            Err(FsError::EntryNotFound)
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => fs.symlink_metadata(&path),
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
     fn remove_file(&self, path: &Path) -> Result<()> {
@@ -220,13 +285,14 @@ impl FileSystem for UnionFileSystem {
 
         if path.as_os_str().is_empty() {
             Err(FsError::NotAFile)
-        } else if let Some((_, path, fs)) = self.find_mount(path.to_owned()) {
-            fs.remove_file(&path)
         } else {
-            Err(FsError::EntryNotFound)
+            match self.find_mount(path.to_owned()) {
+                Some((_, path, fs)) => fs.remove_file(&path),
+                _ => Err(FsError::EntryNotFound),
+            }
         }
     }
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
 
@@ -292,12 +358,12 @@ impl FileOpener for UnionFileSystem {
         } else {
             let parent = path.parent().unwrap();
             let file_name = path.file_name().unwrap();
-            if let Some((_, path, fs)) = self.find_mount(parent.to_owned()) {
-                fs.new_open_options()
+            match self.find_mount(parent.to_owned()) {
+                Some((_, path, fs)) => fs
+                    .new_open_options()
                     .options(conf.clone())
-                    .open(path.join(file_name))
-            } else {
-                Err(FsError::EntryNotFound)
+                    .open(path.join(file_name)),
+                _ => Err(FsError::EntryNotFound),
             }
         }
     }
@@ -312,7 +378,7 @@ mod tests {
 
     use tokio::io::AsyncWriteExt;
 
-    use crate::{mem_fs, FileSystem as FileSystemTrait, FsError, UnionFileSystem};
+    use crate::{FileSystem as FileSystemTrait, FsError, UnionFileSystem, mem_fs};
 
     use super::{FileOpener, OpenOptionsConfig};
 
@@ -490,12 +556,14 @@ mod tests {
         assert!(fs.symlink_metadata(&PathBuf::from("/app")).is_ok());
         assert!(fs.symlink_metadata(&PathBuf::from("/app/a")).is_ok());
         assert!(fs.symlink_metadata(&PathBuf::from("/app/b")).is_ok());
-        assert!(fs
-            .symlink_metadata(&PathBuf::from("/app/a/data-a.txt"))
-            .is_ok());
-        assert!(fs
-            .symlink_metadata(&PathBuf::from("/app/b/data-b.txt"))
-            .is_ok());
+        assert!(
+            fs.symlink_metadata(&PathBuf::from("/app/a/data-a.txt"))
+                .is_ok()
+        );
+        assert!(
+            fs.symlink_metadata(&PathBuf::from("/app/b/data-b.txt"))
+                .is_ok()
+        );
     }
 
     #[tokio::test]
@@ -520,7 +588,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 +601,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 +712,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 +767,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 +981,7 @@ mod tests {
             "creating `b.txt`",
         );
 
-        println!("fs: {:?}", fs);
+        println!("fs: {fs:?}");
 
         let readdir = fs.read_dir(Path::new("/test_readdir"));
 
@@ -923,7 +991,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 +1011,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..5a6e289db9 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,
+    Container, Metadata as WebcMetadata, PathSegmentError, PathSegments, ToPathSegments, Volume,
+    compat::SharedBytes,
 };
 
 use crate::{
@@ -152,7 +152,7 @@ impl FileSystem for WebcVolumeFileSystem {
         Err(FsError::PermissionDenied)
     }
 
-    fn new_open_options(&self) -> crate::OpenOptions {
+    fn new_open_options(&self) -> crate::OpenOptions<'_> {
         crate::OpenOptions::new(self)
     }
 
@@ -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-fs/src/zero_file.rs b/lib/virtual-fs/src/zero_file.rs
index 297a5fa30e..6abc159f6b 100644
--- a/lib/virtual-fs/src/zero_file.rs
+++ b/lib/virtual-fs/src/zero_file.rs
@@ -56,7 +56,7 @@ impl AsyncRead for ZeroFile {
         _cx: &mut Context<'_>,
         buf: &mut tokio::io::ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        let zeros: Vec<u8> = iter::repeat(0).take(buf.remaining()).collect();
+        let zeros: Vec<u8> = iter::repeat_n(0, buf.remaining()).collect();
         buf.put_slice(&zeros[..]);
         Poll::Ready(Ok(()))
     }
diff --git a/lib/virtual-io/Cargo.toml b/lib/virtual-io/Cargo.toml
index 4d25ba0753..23fa222bb4 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.700.0"
 description = "Wasmer Virtual IO Engine powered by mio"
 authors.workspace = true
 edition.workspace = true
@@ -10,15 +10,20 @@ 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" }
-futures = { version = "0.3" }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
+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.workspace = true
+serde = { workspace = true, default-features = false, features = ["derive"] }
+parking.workspace = true
+
+[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..60d5596014 100644
--- a/lib/virtual-io/src/guard.rs
+++ b/lib/virtual-io/src/guard.rs
@@ -43,17 +43,18 @@ impl InterestGuard {
         &mut self,
         handler: Box<dyn InterestHandler + Send + Sync>,
     ) -> Result<(), Box<dyn InterestHandler + Send + Sync>> {
-        if let Some(selector) = self.selector.upgrade() {
-            selector.replace(self.token, handler);
-            Ok(())
-        } else {
-            Err(handler)
+        match self.selector.upgrade() {
+            Some(selector) => {
+                selector.replace(self.token, handler);
+                Ok(())
+            }
+            _ => Err(handler),
         }
     }
 
     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..b53e018eb3 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::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
 };
 
-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(), 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_all(&[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_all(&[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_all(&[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_all(&[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..a2c8e9afbd 100644
--- a/lib/virtual-io/src/waker.rs
+++ b/lib/virtual-io/src/waker.rs
@@ -1,83 +1,22 @@
-#![allow(dead_code, unused)]
-use std::{
-    sync::{Arc, Condvar, Mutex},
-    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-};
+use std::task::{Context, Poll, Waker};
 
 use futures::Future;
 
-pub struct InlineWaker {
-    lock: Mutex<()>,
-    condvar: Condvar,
-}
-impl InlineWaker {
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            lock: Mutex::new(()),
-            condvar: Condvar::new(),
-        })
-    }
-
-    fn wake_now(&self) {
-        // Note: This guard should be there to prevent race conditions however in the
-        // browser it causes a lock up - some strange browser issue. What I suspect
-        // is that the Condvar::wait call is not releasing the mutex lock
-        #[cfg(not(feature = "js"))]
-        let _guard = self.lock.lock().unwrap();
-
-        self.condvar.notify_all();
-    }
-
-    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) }
-    }
-
-    #[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();
-        let waker = inline_waker.as_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        // We loop waiting for the waker to be woken, then we poll again
-        let mut task = Box::pin(task);
-        loop {
-            let lock = inline_waker.lock.lock().unwrap();
-            match task.as_mut().poll(&mut cx) {
-                Poll::Pending => {
-                    inline_waker.condvar.wait(lock).ok();
-                }
-                Poll::Ready(ret) => {
-                    return ret;
-                }
+pub fn block_on<'a, A>(task: impl Future<Output = A> + 'a) -> A {
+    // Create the waker
+    let (parker, unparker) = parking::pair();
+    let waker = Waker::from(unparker.clone());
+    let mut cx = Context::from_waker(&waker);
+
+    let mut task = Box::pin(task);
+    loop {
+        match task.as_mut().poll(&mut cx) {
+            Poll::Pending => {
+                parker.park();
+            }
+            Poll::Ready(ret) => {
+                return ret;
             }
         }
     }
 }
-
-fn inline_waker_wake(s: &InlineWaker) {
-    let waker_arc = unsafe { Arc::from_raw(s) };
-    waker_arc.wake_now();
-}
-
-fn inline_waker_clone(s: &InlineWaker) -> 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 InlineWaker)), // clone
-        |s| inline_waker_wake(&*(s as *const InlineWaker)),  // wake
-        |s| (*(s as *const InlineWaker)).wake_now(), // wake by ref (don't decrease refcount)
-        |s| drop(Arc::from_raw(s as *const InlineWaker)), // decrease refcount
-    )
-};
diff --git a/lib/virtual-net/Cargo.toml b/lib/virtual-net/Cargo.toml
index b7b01572ca..96b598abf0 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.700.0"
 description = "Wasmer Virtual Networking"
 authors.workspace = true
 edition.workspace = true
@@ -10,51 +10,74 @@ 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"] }
-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"
-bincode = { version = "1.3" }
-serde = { version = "1.0", 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 }
-tokio-util = { version = "0.7.8", features = ["codec"], optional = true }
-hyper-tungstenite = { version = "0.13", optional = true }
+base64.workspace = 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 }
+
+ipnet.workspace = true
+iprange.workspace = true
+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 = { workspace = true, optional = true }
+socket2 = { workspace = true, optional = true }
+derive_more.workspace = true
+virtual-mio = { path = "../virtual-io", version = "0.700.0", default-features = false }
+bincode = { workspace = true, features = ["serde"] }
+serde = { workspace = true, default-features = false, features = ["derive"] }
+pin-project-lite.workspace = true
+futures-util.workspace = true
+anyhow.workspace = true
+tokio-serde = { workspace = true, features = ["bincode"], optional = true }
+tokio-util = { workspace = true, features = ["codec"], optional = true }
+hyper-tungstenite = { workspace = true, 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"
+workspace = true
 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" }
-serial_test = "2.0.0"
+tokio = { workspace = true, default-features = false, features = [
+	"macros",
+	"rt-multi-thread",
+] }
+tracing-test.workspace = true
+serial_test.workspace = true
 
 [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..52d66ac9fc 100644
--- a/lib/virtual-net/src/client.rs
+++ b/lib/virtual-net/src/client.rs
@@ -4,10 +4,10 @@ use std::future::Future;
 use std::net::IpAddr;
 use std::net::SocketAddr;
 use std::pin::Pin;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::Mutex;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
 use std::task::Context;
 use std::task::Poll;
 use std::task::RawWaker;
@@ -17,18 +17,19 @@ 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;
+use futures_util::future::BoxFuture;
+use futures_util::stream::FuturesOrdered;
+#[cfg(feature = "hyper")]
 use hyper_util::rt::tokio::TokioIo;
 use tokio::io::AsyncRead;
 use tokio::io::AsyncWrite;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::error::TryRecvError;
 use tokio::sync::mpsc::error::TrySendError;
+use tokio_serde::SymmetricallyFramed;
 use tokio_serde::formats::SymmetricalBincode;
 #[cfg(feature = "cbor")]
 use tokio_serde::formats::SymmetricalCbor;
@@ -36,19 +37,12 @@ use tokio_serde::formats::SymmetricalCbor;
 use tokio_serde::formats::SymmetricalJson;
 #[cfg(feature = "messagepack")]
 use tokio_serde::formats::SymmetricalMessagePack;
-use tokio_serde::SymmetricallyFramed;
 use tokio_util::codec::FramedRead;
 use tokio_util::codec::FramedWrite;
 use tokio_util::codec::LengthDelimitedCodec;
-use virtual_mio::InlineWaker;
 use virtual_mio::InterestType;
+use virtual_mio::block_on;
 
-use crate::meta;
-use crate::meta::FrameSerializationFormat;
-use crate::meta::RequestType;
-use crate::meta::ResponseType;
-use crate::meta::SocketId;
-use crate::meta::{MessageRequest, MessageResponse};
 use crate::IpCidr;
 use crate::IpRoute;
 use crate::NetworkError;
@@ -63,11 +57,17 @@ use crate::VirtualSocket;
 use crate::VirtualTcpListener;
 use crate::VirtualTcpSocket;
 use crate::VirtualUdpSocket;
+use crate::meta;
+use crate::meta::FrameSerializationFormat;
+use crate::meta::RequestType;
+use crate::meta::ResponseType;
+use crate::meta::SocketId;
+use crate::meta::{MessageRequest, MessageResponse};
 
+use crate::Result;
 use crate::rx_tx::RemoteRx;
 use crate::rx_tx::RemoteTx;
 use crate::rx_tx::RemoteTxWakers;
-use crate::Result;
 
 #[derive(Debug, Clone)]
 pub struct RemoteNetworkingClient {
@@ -314,10 +314,13 @@ impl Future for RemoteNetworkingClientDriver {
                     not_stalled_guard.take();
                 }
                 Poll::Pending if not_stalled_guard.is_none() => {
-                    if let Ok(guard) = self.common.stall.clone().try_lock_owned() {
-                        not_stalled_guard.replace(guard);
-                    } else {
-                        return Poll::Pending;
+                    match self.common.stall.clone().try_lock_owned() {
+                        Ok(guard) => {
+                            not_stalled_guard.replace(guard);
+                        }
+                        _ => {
+                            return Poll::Pending;
+                        }
                     }
                 }
                 Poll::Pending => {}
@@ -529,12 +532,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 +545,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
@@ -1004,7 +1006,7 @@ impl VirtualSocket for RemoteSocket {
     }
 
     fn ttl(&self) -> Result<u32> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetTtl)) {
+        match block_on(self.io_socket(RequestType::GetTtl)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Ttl(ttl) => Ok(ttl),
             res => {
@@ -1015,7 +1017,7 @@ impl VirtualSocket for RemoteSocket {
     }
 
     fn addr_local(&self) -> Result<SocketAddr> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrLocal)) {
+        match block_on(self.io_socket(RequestType::GetAddrLocal)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::SocketAddr(addr) => Ok(addr),
             res => {
@@ -1026,7 +1028,7 @@ impl VirtualSocket for RemoteSocket {
     }
 
     fn status(&self) -> Result<crate::SocketStatus> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetStatus)) {
+        match block_on(self.io_socket(RequestType::GetStatus)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Status(status) => Ok(status),
             res => {
@@ -1066,10 +1068,10 @@ impl VirtualTcpListener for RemoteSocket {
         // server as the constructor invokes this method and we invoke it here after
         // receiving a child connection.
         let mut rx_recv = None;
-        if let Some((rx_socket, existing_rx_recv)) = self.pending_accept.take() {
-            if accepted.socket == rx_socket {
-                rx_recv.replace(existing_rx_recv);
-            }
+        if let Some((rx_socket, existing_rx_recv)) = self.pending_accept.take()
+            && accepted.socket == rx_socket
+        {
+            rx_recv.replace(existing_rx_recv);
         }
         let rx_recv = match rx_recv {
             Some(rx_recv) => rx_recv,
@@ -1131,7 +1133,7 @@ impl VirtualTcpListener for RemoteSocket {
     }
 
     fn addr_local(&self) -> Result<SocketAddr> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrLocal)) {
+        match block_on(self.io_socket(RequestType::GetAddrLocal)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::SocketAddr(addr) => Ok(addr),
             res => {
@@ -1146,7 +1148,7 @@ impl VirtualTcpListener for RemoteSocket {
     }
 
     fn ttl(&self) -> Result<u8> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetTtl)) {
+        match block_on(self.io_socket(RequestType::GetTtl)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Ttl(val) => Ok(val.try_into().map_err(|_| NetworkError::InvalidData)?),
             res => {
@@ -1196,13 +1198,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() {
@@ -1218,7 +1222,7 @@ impl VirtualRawSocket for RemoteSocket {
     }
 
     fn promiscuous(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetPromiscuous)) {
+        match block_on(self.io_socket(RequestType::GetPromiscuous)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1254,7 +1258,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());
@@ -1274,7 +1286,7 @@ impl VirtualUdpSocket for RemoteSocket {
     }
 
     fn broadcast(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetBroadcast)) {
+        match block_on(self.io_socket(RequestType::GetBroadcast)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1289,7 +1301,7 @@ impl VirtualUdpSocket for RemoteSocket {
     }
 
     fn multicast_loop_v4(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastLoopV4)) {
+        match block_on(self.io_socket(RequestType::GetMulticastLoopV4)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1304,7 +1316,7 @@ impl VirtualUdpSocket for RemoteSocket {
     }
 
     fn multicast_loop_v6(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastLoopV6)) {
+        match block_on(self.io_socket(RequestType::GetMulticastLoopV6)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1319,7 +1331,7 @@ impl VirtualUdpSocket for RemoteSocket {
     }
 
     fn multicast_ttl_v4(&self) -> Result<u32> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastTtlV4)) {
+        match block_on(self.io_socket(RequestType::GetMulticastTtlV4)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Ttl(ttl) => Ok(ttl),
             res => {
@@ -1354,7 +1366,7 @@ impl VirtualUdpSocket for RemoteSocket {
     }
 
     fn addr_peer(&self) -> Result<Option<SocketAddr>> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrPeer)) {
+        match block_on(self.io_socket(RequestType::GetAddrPeer)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::None => Ok(None),
             ResponseType::SocketAddr(addr) => Ok(Some(addr)),
@@ -1374,7 +1386,7 @@ impl VirtualConnectedSocket for RemoteSocket {
     }
 
     fn linger(&self) -> Result<Option<Duration>> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetLinger)) {
+        match block_on(self.io_socket(RequestType::GetLinger)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::None => Ok(None),
             ResponseType::Duration(val) => Ok(Some(val)),
@@ -1422,13 +1434,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() {
@@ -1446,7 +1460,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn recv_buf_size(&self) -> Result<usize> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetRecvBufSize)) {
+        match block_on(self.io_socket(RequestType::GetRecvBufSize)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Amount(amt) => Ok(amt.try_into().map_err(|_| NetworkError::IOError)?),
             res => {
@@ -1461,7 +1475,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn send_buf_size(&self) -> Result<usize> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetSendBufSize)) {
+        match block_on(self.io_socket(RequestType::GetSendBufSize)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Amount(val) => Ok(val.try_into().map_err(|_| NetworkError::IOError)?),
             res => {
@@ -1476,7 +1490,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn nodelay(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetNoDelay)) {
+        match block_on(self.io_socket(RequestType::GetNoDelay)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1491,7 +1505,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn keepalive(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetKeepAlive)) {
+        match block_on(self.io_socket(RequestType::GetKeepAlive)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1506,7 +1520,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn dontroute(&self) -> Result<bool> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetDontRoute)) {
+        match block_on(self.io_socket(RequestType::GetDontRoute)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::Flag(val) => Ok(val),
             res => {
@@ -1517,7 +1531,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn addr_peer(&self) -> Result<SocketAddr> {
-        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrPeer)) {
+        match block_on(self.io_socket(RequestType::GetAddrPeer)) {
             ResponseType::Err(err) => Err(err),
             ResponseType::SocketAddr(addr) => Ok(addr),
             res => {
@@ -1537,7 +1551,7 @@ impl VirtualTcpSocket for RemoteSocket {
     }
 
     fn is_closed(&self) -> bool {
-        match InlineWaker::block_on(self.io_socket(RequestType::IsClosed)) {
+        match block_on(self.io_socket(RequestType::IsClosed)) {
             ResponseType::Flag(val) => val,
             _ => false,
         }
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..ecb8a8f01f 100644
--- a/lib/virtual-net/src/host.rs
+++ b/lib/virtual-net/src/host.rs
@@ -1,13 +1,13 @@
 #![allow(unused_variables)]
-use crate::{io_err_into_net_error, VirtualIoSource};
+use crate::ruleset::{Direction, Ruleset};
 #[allow(unused_imports)]
 use crate::{
     IpCidr, IpRoute, NetworkError, Result, SocketStatus, StreamSecurity, VirtualConnectedSocket,
     VirtualConnectionlessSocket, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket,
     VirtualSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
 };
+use crate::{VirtualIoSource, io_err_into_net_error};
 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;
@@ -23,14 +26,14 @@ use tokio::runtime::Handle;
 #[allow(unused_imports, dead_code)]
 use tracing::{debug, error, info, trace, warn};
 use virtual_mio::{
-    state_as_waker_map, HandlerGuardState, InterestGuard, InterestHandler, InterestType, Selector,
+    HandlerGuardState, InterestGuard, InterestHandler, InterestType, Selector, state_as_waker_map,
 };
 
-#[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()
+            && !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,41 @@ 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>> {
+        #[cfg(not(windows))]
+        use socket2::{Domain, Socket, Type};
+
+        if let Some(ruleset) = self.ruleset.as_ref()
+            && !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 +146,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 +168,15 @@ impl VirtualNetworking for LocalNetworking {
         _addr: SocketAddr,
         mut peer: SocketAddr,
     ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
+        if let Some(ruleset) = self.ruleset.as_ref()
+            && !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 +190,39 @@ impl VirtualNetworking for LocalNetworking {
         port: Option<u16>,
         dns_server: Option<IpAddr>,
     ) -> Result<Vec<IpAddr>> {
+        if let Some(ruleset) = self.ruleset.as_ref()
+            && !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 +230,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()
+                    && !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 +413,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 +460,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 +540,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 +571,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 +753,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 +823,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 +854,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()
+            && !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 +876,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..22ae000a49 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))]
-
+#![cfg_attr(docsrs, feature(doc_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;
@@ -46,16 +47,15 @@ use tokio::io::AsyncWrite;
 pub use bytes::Bytes;
 pub use bytes::BytesMut;
 use serde::{Deserialize, Serialize};
-pub use virtual_mio::{handler_into_waker, InterestHandler};
 #[cfg(feature = "host-net")]
 pub use virtual_mio::{InterestGuard, InterestHandlerWaker, InterestType};
+pub use virtual_mio::{InterestHandler, handler_into_waker};
 
 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
@@ -633,7 +656,7 @@ impl<'a> AsyncRead for Box<dyn VirtualTcpSocket + Sync + 'a> {
             return Poll::Ready(Err(net_error_into_io_err(err)));
         }
         let buf_unsafe = unsafe { buf.unfilled_mut() };
-        match this.try_recv(buf_unsafe) {
+        match this.try_recv(buf_unsafe, false) {
             Ok(ret) => {
                 unsafe { buf.assume_init(ret) };
                 buf.set_filled(ret);
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/meta.rs b/lib/virtual-net/src/meta.rs
index c8875c9c81..7a8f516a8c 100644
--- a/lib/virtual-net/src/meta.rs
+++ b/lib/virtual-net/src/meta.rs
@@ -33,14 +33,14 @@ pub enum FrameSerializationFormat {
     Cbor,
 }
 
-/// Possible values which can be passed to the [`TcpStream::shutdown`] method.
+/// Possible values which can be passed to the `TcpStream::shutdown` method.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
 pub enum Shutdown {
-    /// The reading portion of the [`TcpStream`] should be shut down.
+    /// Shut down the reading portion of the stream.
     Read,
-    /// The writing portion of the [`TcpStream`] should be shut down.
+    /// Shut down the writing portion of the stream.
     Write,
-    /// Both the reading and the writing portions of the [`TcpStream`] should be shut down.
+    /// Shut down both the reading and writing portions of the stream.
     Both,
 }
 
diff --git a/lib/virtual-net/src/ruleset.rs b/lib/virtual-net/src/ruleset.rs
new file mode 100644
index 0000000000..0cc7e42ae0
--- /dev/null
+++ b/lib/virtual-net/src/ruleset.rs
@@ -0,0 +1,1489 @@
+/// 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
+            && 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 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))
+        }
+    }
+
+    /// 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 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))
+        }
+    }
+
+    /// 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..576d05e466 100644
--- a/lib/virtual-net/src/rx_tx.rs
+++ b/lib/virtual-net/src/rx_tx.rs
@@ -1,26 +1,24 @@
 use std::{
-    io,
     pin::Pin,
     sync::{Arc, Mutex},
     task::{Context, Poll, Waker},
 };
 
 use crate::Result;
-use futures_util::{future::BoxFuture, Future, Sink, SinkExt, Stream};
+use bincode::config;
+use bytes::Bytes;
+use futures_util::{Future, Sink, SinkExt, Stream, future::BoxFuture};
+#[cfg(feature = "hyper")]
 use hyper_util::rt::tokio::TokioIo;
 use serde::Serialize;
 #[cfg(feature = "tokio-tungstenite")]
 use tokio::net::TcpStream;
-use tokio::{
-    io::AsyncWrite,
-    sync::{
-        mpsc::{self, error::TrySendError},
-        oneshot,
-    },
+use tokio::sync::{
+    mpsc::{self, error::TrySendError},
+    oneshot,
 };
-use virtual_mio::InlineWaker;
 
-use crate::{io_err_into_net_error, NetworkError};
+use crate::{NetworkError, io_err_into_net_error};
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct RemoteTxWakers {
@@ -39,28 +37,9 @@ impl RemoteTxWakers {
     }
 }
 
-#[derive(Debug, Default)]
-struct FailOnWrite {}
-impl AsyncWrite for FailOnWrite {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-        _buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
-    }
-}
-
 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 +50,7 @@ where
         wakers: RemoteTxWakers,
     },
     Stream {
+        #[debug(ignore)]
         tx: Arc<tokio::sync::Mutex<StreamSink<T>>>,
         work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
         wakers: RemoteTxWakers,
@@ -135,38 +115,44 @@ where
             #[cfg(feature = "hyper")]
             RemoteTx::HyperWebSocket { tx, format, .. } => {
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Err(NetworkError::IOError);
                     }
                 };
                 let mut tx = tx.lock().await;
-                tx.send(hyper_tungstenite::tungstenite::Message::Binary(data))
-                    .await
-                    .map_err(|_| NetworkError::ConnectionAborted)
+                tx.send(hyper_tungstenite::tungstenite::Message::Binary(
+                    Bytes::from_owner(data),
+                ))
+                .await
+                .map_err(|_| NetworkError::ConnectionAborted)
             }
             #[cfg(feature = "tokio-tungstenite")]
             RemoteTx::TokioWebSocket { tx, format, .. } => {
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Err(NetworkError::IOError);
                     }
                 };
                 let mut tx = tx.lock().await;
-                tx.send(tokio_tungstenite::tungstenite::Message::Binary(data))
-                    .await
-                    .map_err(|_| NetworkError::ConnectionAborted)
+                tx.send(tokio_tungstenite::tungstenite::Message::Binary(
+                    Bytes::from_owner(data),
+                ))
+                .await
+                .map_err(|_| NetworkError::ConnectionAborted)
             }
         }
     }
@@ -238,11 +224,12 @@ where
                 }
 
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Poll::Ready(Err(NetworkError::IOError));
@@ -251,7 +238,9 @@ where
 
                 let mut job = Box::pin(async move {
                     if let Err(err) = tx_guard
-                        .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                        .send(hyper_tungstenite::tungstenite::Message::Binary(
+                            Bytes::from_owner(data),
+                        ))
                         .await
                     {
                         tracing::error!("failed to send remaining bytes for request - {}", err);
@@ -296,11 +285,12 @@ where
                 }
 
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Poll::Ready(Err(NetworkError::IOError));
@@ -309,7 +299,9 @@ where
 
                 let mut job = Box::pin(async move {
                     if let Err(err) = tx_guard
-                        .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                        .send(tokio_tungstenite::tungstenite::Message::Binary(
+                            Bytes::from_owner(data),
+                        ))
                         .await
                     {
                         tracing::error!("failed to send remaining bytes for request - {}", err);
@@ -360,8 +352,7 @@ where
                     }
                 };
 
-                let inline_waker = InlineWaker::new();
-                let waker = inline_waker.as_waker();
+                let waker = NoopWaker::new_waker();
                 let mut cx = Context::from_waker(&waker);
 
                 let mut job = Box::pin(async move {
@@ -388,11 +379,12 @@ where
                 tx, format, work, ..
             } => {
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Err(NetworkError::IOError);
@@ -406,7 +398,9 @@ where
                         work.send(Box::pin(async move {
                             let mut tx_guard = tx.lock().await;
                             tx_guard
-                                .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                                .send(hyper_tungstenite::tungstenite::Message::Binary(
+                                    Bytes::from_owner(data),
+                                ))
                                 .await
                                 .ok();
                         }))
@@ -415,13 +409,14 @@ where
                     }
                 };
 
-                let inline_waker = InlineWaker::new();
-                let waker = inline_waker.as_waker();
+                let waker = NoopWaker::new_waker();
                 let mut cx = Context::from_waker(&waker);
 
                 let mut job = Box::pin(async move {
                     if let Err(err) = tx_guard
-                        .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                        .send(hyper_tungstenite::tungstenite::Message::Binary(
+                            Bytes::from_owner(data),
+                        ))
                         .await
                     {
                         tracing::error!("failed to send remaining bytes for request - {}", err);
@@ -446,11 +441,12 @@ where
                 tx, format, work, ..
             } => {
                 let data = match format {
-                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
-                        .map_err(|err| {
+                    crate::meta::FrameSerializationFormat::Bincode => {
+                        bincode::serde::encode_to_vec(&req, config::legacy()).map_err(|err| {
                             tracing::warn!("failed to serialize message - {err}");
                             NetworkError::IOError
-                        })?,
+                        })?
+                    }
                     format => {
                         tracing::warn!("format not currently supported - {format:?}");
                         return Err(NetworkError::IOError);
@@ -464,7 +460,9 @@ where
                         work.send(Box::pin(async move {
                             let mut tx_guard = tx.lock().await;
                             tx_guard
-                                .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                                .send(tokio_tungstenite::tungstenite::Message::Binary(
+                                    Bytes::from_owner(data),
+                                ))
                                 .await
                                 .ok();
                         }))
@@ -473,13 +471,14 @@ where
                     }
                 };
 
-                let inline_waker = InlineWaker::new();
-                let waker = inline_waker.as_waker();
+                let waker = NoopWaker::new_waker();
                 let mut cx = Context::from_waker(&waker);
 
                 let mut job = Box::pin(async move {
                     if let Err(err) = tx_guard
-                        .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                        .send(tokio_tungstenite::tungstenite::Message::Binary(
+                            Bytes::from_owner(data),
+                        ))
                         .await
                     {
                         tracing::error!("failed to send remaining bytes for request - {}", err);
@@ -503,6 +502,7 @@ where
     }
 }
 
+#[derive(derive_more::Debug)]
 pub(crate) enum RemoteRx<T>
 where
     T: serde::de::DeserializeOwned,
@@ -512,6 +512,7 @@ where
         wakers: RemoteTxWakers,
     },
     Stream {
+        #[debug(ignore)]
         rx: Pin<Box<dyn Stream<Item = std::io::Result<T>> + Send + 'static>>,
     },
     #[cfg(feature = "hyper")]
@@ -557,13 +558,16 @@ where
                     Poll::Ready(Some(Ok(hyper_tungstenite::tungstenite::Message::Binary(msg)))) => {
                         match format {
                             crate::meta::FrameSerializationFormat::Bincode => {
-                                return match bincode::deserialize(&msg) {
-                                    Ok(msg) => Poll::Ready(Some(msg)),
+                                return match bincode::serde::decode_from_slice(
+                                    &msg,
+                                    config::legacy(),
+                                ) {
+                                    Ok((msg, _)) => Poll::Ready(Some(msg)),
                                     Err(err) => {
                                         tracing::warn!("failed to deserialize message - {}", err);
                                         continue;
                                     }
-                                }
+                                };
                             }
                             format => {
                                 tracing::warn!("format not currently supported - {format:?}");
@@ -587,13 +591,16 @@ where
                     Poll::Ready(Some(Ok(tokio_tungstenite::tungstenite::Message::Binary(msg)))) => {
                         match format {
                             crate::meta::FrameSerializationFormat::Bincode => {
-                                return match bincode::deserialize(&msg) {
-                                    Ok(msg) => Poll::Ready(Some(msg)),
+                                return match bincode::serde::decode_from_slice(
+                                    &msg,
+                                    config::legacy(),
+                                ) {
+                                    Ok((msg, _)) => Poll::Ready(Some(msg)),
                                     Err(err) => {
                                         tracing::warn!("failed to deserialize message - {}", err);
                                         continue;
                                     }
-                                }
+                                };
                             }
                             format => {
                                 tracing::warn!("format not currently supported - {format:?}");
@@ -616,3 +623,15 @@ where
         }
     }
 }
+
+struct NoopWaker;
+
+impl NoopWaker {
+    fn new_waker() -> Waker {
+        Waker::from(Arc::new(Self))
+    }
+}
+
+impl std::task::Wake for NoopWaker {
+    fn wake(self: Arc<Self>) {}
+}
diff --git a/lib/virtual-net/src/server.rs b/lib/virtual-net/src/server.rs
index 73859d428e..7a0b8a6c6f 100644
--- a/lib/virtual-net/src/server.rs
+++ b/lib/virtual-net/src/server.rs
@@ -1,22 +1,22 @@
 use crate::meta::{FrameSerializationFormat, ResponseType};
 use crate::rx_tx::{RemoteRx, RemoteTx, RemoteTxWakers};
+use crate::{IpCidr, IpRoute, NetworkError, StreamSecurity, VirtualIcmpSocket};
 use crate::{
-    meta::{MessageRequest, MessageResponse, RequestType, SocketId},
     VirtualNetworking, VirtualRawSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+    meta::{MessageRequest, MessageResponse, RequestType, SocketId},
 };
-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};
-use futures_util::{future::BoxFuture, StreamExt};
 use futures_util::{Sink, Stream};
+use futures_util::{StreamExt, future::BoxFuture};
 use std::collections::HashSet;
 use std::mem::MaybeUninit;
 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,
@@ -30,6 +30,7 @@ use tokio::{
     io::{AsyncRead, AsyncWrite},
     sync::mpsc,
 };
+use tokio_serde::SymmetricallyFramed;
 use tokio_serde::formats::SymmetricalBincode;
 #[cfg(feature = "cbor")]
 use tokio_serde::formats::SymmetricalCbor;
@@ -37,7 +38,6 @@ use tokio_serde::formats::SymmetricalCbor;
 use tokio_serde::formats::SymmetricalJson;
 #[cfg(feature = "messagepack")]
 use tokio_serde::formats::SymmetricalMessagePack;
-use tokio_serde::SymmetricallyFramed;
 use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
 use virtual_mio::InterestHandler;
 
@@ -369,10 +369,13 @@ impl Future for RemoteNetworkingServerDriver {
                     not_stalled_guard.take();
                 }
                 Poll::Pending if not_stalled_guard.is_none() => {
-                    if let Ok(guard) = self.common.stall_rx.clone().try_lock_owned() {
-                        not_stalled_guard.replace(guard);
-                    } else {
-                        return Poll::Pending;
+                    match self.common.stall_rx.clone().try_lock_owned() {
+                        Ok(guard) => {
+                            not_stalled_guard.replace(guard);
+                        }
+                        _ => {
+                            return Poll::Pending;
+                        }
                     }
                 }
                 Poll::Pending => {}
@@ -572,7 +575,7 @@ impl RemoteNetworkingServerDriver {
                             req_id,
                             res: ResponseType::Err(NetworkError::InvalidFd),
                         })
-                    })
+                    });
                 }
             };
             work(socket)
@@ -1222,6 +1225,7 @@ impl RemoteNetworkingServerDriver {
     }
 }
 
+#[derive(Debug)]
 enum RemoteAdapterSocket {
     TcpListener {
         socket: Box<dyn VirtualTcpListener + Sync + 'static>,
@@ -1455,7 +1459,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 +1479,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 +1500,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 +1521,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];
@@ -1545,7 +1549,7 @@ impl RemoteAdapterSocket {
                 // Processes all the background tasks until completion
                 let mut stream = ret;
                 loop {
-                    let (next, s) = stream.into_future().await;
+                    let (next, s) = StreamExt::into_future(stream).await;
                     if next.is_none() {
                         break;
                     }
@@ -1615,14 +1619,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..08927ab756 100644
--- a/lib/virtual-net/src/tcp_pair.rs
+++ b/lib/virtual-net/src/tcp_pair.rs
@@ -1,6 +1,6 @@
 use crate::{
-    net_error_into_io_err, InterestHandler, NetworkError, SocketStatus, VirtualConnectedSocket,
-    VirtualIoSource, VirtualSocket, VirtualTcpSocket,
+    InterestHandler, NetworkError, SocketStatus, VirtualConnectedSocket, VirtualIoSource,
+    VirtualSocket, VirtualTcpSocket, net_error_into_io_err,
 };
 use bytes::{Buf, Bytes};
 use futures_util::Future;
@@ -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/virtual-net/src/tests.rs b/lib/virtual-net/src/tests.rs
index 244998243e..e972f118de 100644
--- a/lib/virtual-net/src/tests.rs
+++ b/lib/virtual-net/src/tests.rs
@@ -9,8 +9,8 @@ use tracing_test::traced_test;
 #[cfg(feature = "remote")]
 use crate::RemoteNetworkingServer;
 use crate::{
-    host::LocalNetworking, meta::FrameSerializationFormat, VirtualConnectedSocketExt,
-    VirtualTcpListenerExt,
+    VirtualConnectedSocketExt, VirtualTcpListenerExt, host::LocalNetworking,
+    meta::FrameSerializationFormat,
 };
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
@@ -440,7 +440,7 @@ async fn test_google_epoll() {
         let mut done = false;
         for n in 0.. {
             let mut buf: [MaybeUninit<u8>; 4096] = [MaybeUninit::uninit(); 4096];
-            match socket.try_recv(&mut buf) {
+            match socket.try_recv(&mut buf, false) {
                 Ok(0) => {
                     done = true;
                     break;
@@ -467,7 +467,9 @@ async fn test_google_epoll() {
     }
 
     if false_interest > 20 {
-        panic!("too many false positives on the epoll ({false_interest}), something has likely gone wrong")
+        panic!(
+            "too many false positives on the epoll ({false_interest}), something has likely gone wrong"
+        )
     }
 
     tracing::info!("done");
diff --git a/lib/vm/Cargo.toml b/lib/vm/Cargo.toml
index 0fcf37541f..56339022eb 100644
--- a/lib/vm/Cargo.toml
+++ b/lib/vm/Cargo.toml
@@ -15,40 +15,52 @@ version.workspace = true
 [dependencies]
 memoffset.workspace = true
 dashmap.workspace = true
-wasmer-types = { path = "../types", version = "=4.3.7" }
+wasmer-types = { path = "../types", version = "=7.0.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"
-scopeguard = "1.1.0"
-lazy_static = "1.4.0"
-region = { version = "3.0.2" }
-corosensei = { version = "0.1.2" }
-derivative = { version = "^2" }
-fnv = "1.0.3"
+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.workspace = true
+region.workspace = true
+corosensei.workspace = true
+fnv.workspace = true
+parking_lot.workspace = true
 # - Optional shared dependencies.
-tracing = { version = "0.1", optional = true }
-crossbeam-queue = "0.3.8"
+tracing = { workspace = true, optional = true }
+crossbeam-queue.workspace = true
+loupe = { workspace = true, optional = true }
+gimli.workspace = true
+
+[target.'cfg(any(target_family = "unix", all(target_family = "windows", target_env = "gnu")))'.dependencies]
+libunwind.workspace = true
 
 [target.'cfg(target_vendor = "apple")'.dependencies]
-mach2 = "0.4.2"
+mach2.workspace = true
 
 [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 = { workspace = true, features = [
+	"Win32_System_Diagnostics_Debug",
+	"Win32_System_Threading",
+	"Win32_System_Kernel",
+	"Win32_System_Memory",
+] }
 
 [build-dependencies]
-cc = "1.0"
+cc.workspace = true
+rustversion.workspace = true
 
 [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/src/exception.rs b/lib/vm/src/exception.rs
new file mode 100644
index 0000000000..7eb932ec3e
--- /dev/null
+++ b/lib/vm/src/exception.rs
@@ -0,0 +1,102 @@
+use backtrace::Backtrace;
+use std::{cell::UnsafeCell, ptr::NonNull};
+use wasmer_types::{RawValue, StoreId};
+
+use crate::{StoreHandle, StoreObjects, VMTag, store::InternalStoreHandle};
+
+/// Underlying object referenced by a `VMExceptionRef`.
+#[derive(Debug)]
+pub struct VMExceptionObj {
+    tag: u32,
+    payload: Box<UnsafeCell<[RawValue]>>,
+    backtrace: Backtrace,
+}
+
+impl VMExceptionObj {
+    /// Creates a new VMExceptionObj from the given tag and values; the tag is assumed
+    /// to be from the same store as the VMExceptionObj itself.
+    pub fn new(tag: InternalStoreHandle<VMTag>, payload: Box<[RawValue]>) -> Self {
+        let payload = Box::into_raw(payload);
+        let backtrace = Backtrace::new_unresolved();
+        // SAFETY: [RawValue] and UnsafeCell[RawValue] have the same memory layout, and Box itself
+        // does not enable any niche optimizations (of the kind that break Outer<UnsafeCell<T>>).
+        Self {
+            tag: tag.index() as u32,
+            payload: unsafe { Box::from_raw(payload as *mut UnsafeCell<[RawValue]>) },
+            backtrace,
+        }
+    }
+
+    /// Creates a new VMExceptionObj from the given tag with all values initialized to
+    /// zero; the tag is assumed to be from the same store as the VMExceptionObj itself.
+    pub fn new_zeroed(ctx: &StoreObjects, tag: InternalStoreHandle<VMTag>) -> Self {
+        let value_count = tag.get(ctx).signature.params().len();
+        let values = Box::into_raw(vec![RawValue::default(); value_count].into_boxed_slice());
+        let backtrace = Backtrace::new_unresolved();
+        // SAFETY: [RawValue] and UnsafeCell[RawValue] have the same memory layout, and Box itself
+        // does not enable any niche optimizations (of the kind that break Outer<UnsafeCell<T>>).
+        Self {
+            tag: tag.index() as u32,
+            payload: unsafe { Box::from_raw(values as *mut UnsafeCell<[RawValue]>) },
+            backtrace,
+        }
+    }
+
+    #[cfg_attr(
+        not(any(
+            all(target_family = "windows", target_env = "gnu"),
+            target_family = "unix",
+        )),
+        allow(unused)
+    )]
+    pub(crate) fn tag_index(&self) -> u32 {
+        self.tag
+    }
+
+    /// Gets the tag of this exception.
+    pub fn tag(&self) -> InternalStoreHandle<VMTag> {
+        InternalStoreHandle::from_index(self.tag as usize).unwrap()
+    }
+
+    /// Gets the payload of this exception.
+    pub fn payload(&self) -> NonNull<[RawValue]> {
+        // SAFETY: UnsafeCell::get always returns a non-null pointer.
+        unsafe { NonNull::new_unchecked(self.payload.get()) }
+    }
+
+    /// Gets the backtrace of this exception at the time it was constructed.
+    pub fn backtrace(&self) -> &Backtrace {
+        &self.backtrace
+    }
+}
+
+// TODO: This is probably the place to do some reference-counting of exception objects.
+/// Represents a reference to a VMExceptionObj.
+#[repr(transparent)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VMExceptionRef(pub StoreHandle<VMExceptionObj>);
+
+impl VMExceptionRef {
+    /// Converts the [`VMExceptionRef`] into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        RawValue {
+            exnref: self.to_u32_exnref(),
+        }
+    }
+
+    /// Gets the raw u32 exnref value.
+    pub fn to_u32_exnref(&self) -> u32 {
+        self.0.internal_handle().index() as u32
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(store_id: StoreId, raw: RawValue) -> Option<Self> {
+        unsafe {
+            InternalStoreHandle::from_index(raw.exnref as usize)
+                .map(|handle| Self(StoreHandle::from_internal(store_id, handle)))
+        }
+    }
+}
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..dc9f882782 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>,
 }
 
@@ -45,6 +42,6 @@ impl VMExternRef {
     /// # Safety
     /// `raw` must be a valid `VMExternRef` instance.
     pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
-        InternalStoreHandle::from_index(raw.externref).map(Self)
+        unsafe { InternalStoreHandle::from_index(raw.externref).map(Self) }
     }
 }
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/allocator.rs b/lib/vm/src/instance/allocator.rs
index 78f41fbadb..9f35962d73 100644
--- a/lib/vm/src/instance/allocator.rs
+++ b/lib/vm/src/instance/allocator.rs
@@ -1,21 +1,21 @@
 use super::{Instance, VMInstance};
-use crate::vmcontext::VMTableDefinition;
 use crate::VMMemoryDefinition;
+use crate::vmcontext::VMTableDefinition;
 use std::alloc::{self, Layout};
 use std::convert::TryFrom;
 use std::mem;
 use std::ptr::{self, NonNull};
-use wasmer_types::entity::EntityRef;
 use wasmer_types::VMOffsets;
+use wasmer_types::entity::EntityRef;
 use wasmer_types::{LocalMemoryIndex, LocalTableIndex, ModuleInfo};
 
 /// This is an intermediate type that manages the raw allocation and
-/// metadata when creating an [`Instance`].
+/// metadata when creating a [`VMInstance`].
 ///
 /// This type will free the allocated memory if it's dropped before
 /// being used.
 ///
-/// It is important to remind that [`Instance`] is dynamically-sized
+/// It is important to remind that [`VMInstance`] is dynamically-sized
 /// based on `VMOffsets`: The `Instance.vmctx` field represents a
 /// dynamically-sized array that extends beyond the nominal end of the
 /// type. So in order to create an instance of it, we must:
@@ -23,12 +23,12 @@ use wasmer_types::{LocalMemoryIndex, LocalTableIndex, ModuleInfo};
 /// 1. Define the correct layout for `Instance` (size and alignment),
 /// 2. Allocate it properly.
 ///
-/// The [`InstanceAllocator::instance_layout`] computes the correct
-/// layout to represent the wanted [`Instance`].
+/// The `InstanceAllocator::instance_layout` helper computes the correct
+/// layout to represent the wanted [`VMInstance`].
 ///
 /// Then we use this layout to allocate an empty `Instance` properly.
 pub struct InstanceAllocator {
-    /// The buffer that will contain the [`Instance`] and dynamic fields.
+    /// The buffer that will contain the [`VMInstance`] and dynamic fields.
     instance_ptr: NonNull<Instance>,
 
     /// The layout of the `instance_ptr` buffer.
@@ -104,7 +104,7 @@ impl InstanceAllocator {
         (allocator, memories, tables)
     }
 
-    /// Calculate the appropriate layout for the [`Instance`].
+    /// Calculate the appropriate layout for the internal `Instance` structure.
     fn instance_layout(offsets: &VMOffsets) -> Layout {
         let vmctx_size = usize::try_from(offsets.size_of_vmctx())
             .expect("Failed to convert the size of `vmctx` to a `usize`");
@@ -131,26 +131,28 @@ impl InstanceAllocator {
     ///   memory, i.e. `Self.instance_ptr` must have been allocated by
     ///   `Self::new`.
     unsafe fn memory_definition_locations(&self) -> Vec<NonNull<VMMemoryDefinition>> {
-        let num_memories = self.offsets.num_local_memories();
-        let num_memories = usize::try_from(num_memories).unwrap();
-        let mut out = Vec::with_capacity(num_memories);
+        unsafe {
+            let num_memories = self.offsets.num_local_memories();
+            let num_memories = usize::try_from(num_memories).unwrap();
+            let mut out = Vec::with_capacity(num_memories);
 
-        // We need to do some pointer arithmetic now. The unit is `u8`.
-        let ptr = self.instance_ptr.cast::<u8>().as_ptr();
-        let base_ptr = ptr.add(mem::size_of::<Instance>());
+            // We need to do some pointer arithmetic now. The unit is `u8`.
+            let ptr = self.instance_ptr.cast::<u8>().as_ptr();
+            let base_ptr = ptr.add(mem::size_of::<Instance>());
 
-        for i in 0..num_memories {
-            let mem_offset = self
-                .offsets
-                .vmctx_vmmemory_definition(LocalMemoryIndex::new(i));
-            let mem_offset = usize::try_from(mem_offset).unwrap();
+            for i in 0..num_memories {
+                let mem_offset = self
+                    .offsets
+                    .vmctx_vmmemory_definition(LocalMemoryIndex::new(i));
+                let mem_offset = usize::try_from(mem_offset).unwrap();
 
-            let new_ptr = NonNull::new_unchecked(base_ptr.add(mem_offset));
+                let new_ptr = NonNull::new_unchecked(base_ptr.add(mem_offset));
 
-            out.push(new_ptr.cast());
-        }
+                out.push(new_ptr.cast());
+            }
 
-        out
+            out
+        }
     }
 
     /// Get the locations of where the [`VMTableDefinition`]s should be stored.
@@ -165,28 +167,30 @@ impl InstanceAllocator {
     ///   memory, i.e. `Self.instance_ptr` must have been allocated by
     ///   `Self::new`.
     unsafe fn table_definition_locations(&self) -> Vec<NonNull<VMTableDefinition>> {
-        let num_tables = self.offsets.num_local_tables();
-        let num_tables = usize::try_from(num_tables).unwrap();
-        let mut out = Vec::with_capacity(num_tables);
+        unsafe {
+            let num_tables = self.offsets.num_local_tables();
+            let num_tables = usize::try_from(num_tables).unwrap();
+            let mut out = Vec::with_capacity(num_tables);
 
-        // We need to do some pointer arithmetic now. The unit is `u8`.
-        let ptr = self.instance_ptr.cast::<u8>().as_ptr();
-        let base_ptr = ptr.add(std::mem::size_of::<Instance>());
+            // We need to do some pointer arithmetic now. The unit is `u8`.
+            let ptr = self.instance_ptr.cast::<u8>().as_ptr();
+            let base_ptr = ptr.add(std::mem::size_of::<Instance>());
 
-        for i in 0..num_tables {
-            let table_offset = self
-                .offsets
-                .vmctx_vmtable_definition(LocalTableIndex::new(i));
-            let table_offset = usize::try_from(table_offset).unwrap();
+            for i in 0..num_tables {
+                let table_offset = self
+                    .offsets
+                    .vmctx_vmtable_definition(LocalTableIndex::new(i));
+                let table_offset = usize::try_from(table_offset).unwrap();
 
-            let new_ptr = NonNull::new_unchecked(base_ptr.add(table_offset));
+                let new_ptr = NonNull::new_unchecked(base_ptr.add(table_offset));
 
-            out.push(new_ptr.cast());
+                out.push(new_ptr.cast());
+            }
+            out
         }
-        out
     }
 
-    /// Finish preparing by writing the [`Instance`] into memory, and
+    /// Finish preparing by writing the internal `Instance` into memory, and
     /// consume this `InstanceAllocator`.
     pub(crate) fn into_vminstance(mut self, instance: Instance) -> VMInstance {
         // Prevent the old state's drop logic from being called as we
diff --git a/lib/vm/src/instance/mod.rs b/lib/vm/src/instance/mod.rs
index fa61069f0d..9b4cdb21d6 100644
--- a/lib/vm/src/instance/mod.rs
+++ b/lib/vm/src/instance/mod.rs
@@ -8,20 +8,20 @@
 
 mod allocator;
 
-use crate::export::VMExtern;
+use crate::LinearMemory;
 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, memory_copy, memory_fill, memory32_atomic_check32, memory32_atomic_check64,
 };
-use crate::{FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMFunctionBody};
-use crate::{LinearMemory, NotifyLocation};
+use crate::{FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMTag, wasmer_call_trampoline};
 use crate::{VMConfig, VMFuncRef, VMFunction, VMGlobal, VMMemory, VMTable};
+use crate::{export::VMExtern, threadconditions::ExpectedValue};
 pub use allocator::InstanceAllocator;
 use memoffset::offset_of;
 use more_asserts::assert_lt;
@@ -34,11 +34,12 @@ use std::mem;
 use std::ptr::{self, NonNull};
 use std::slice;
 use std::sync::Arc;
-use wasmer_types::entity::{packed_option::ReservedValue, BoxedSlice, EntityRef, PrimaryMap};
+use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap, packed_option::ReservedValue};
 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 +69,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>,
 
@@ -108,9 +112,11 @@ impl Instance {
     /// Helper function to access various locations offset from our `*mut
     /// VMContext` object.
     unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *mut T {
-        (self.vmctx_ptr() as *mut u8)
-            .add(usize::try_from(offset).unwrap())
-            .cast()
+        unsafe {
+            (self.vmctx_ptr() as *mut u8)
+                .add(usize::try_from(offset).unwrap())
+                .cast()
+        }
     }
 
     fn module(&self) -> &Arc<ModuleInfo> {
@@ -121,11 +127,11 @@ impl Instance {
         &self.module
     }
 
-    fn context(&self) -> &StoreObjects {
+    pub(crate) fn context(&self) -> &StoreObjects {
         unsafe { &*self.context }
     }
 
-    fn context_mut(&mut self) -> &mut StoreObjects {
+    pub(crate) fn context_mut(&mut self) -> &mut StoreObjects {
         unsafe { &mut *self.context }
     }
 
@@ -183,6 +189,18 @@ impl Instance {
         unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_globals_begin()) }
     }
 
+    /// Return the indexed `VMSharedTagIndex`.
+    #[cfg_attr(target_os = "windows", allow(dead_code))]
+    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 +373,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(),
+            )
         }
     }
 
@@ -599,10 +626,8 @@ impl Instance {
             .get(&elem_index)
             .map_or::<&[Option<VMFuncRef>], _>(&[], |e| &**e);
 
-        if src
-            .checked_add(len)
-            .map_or(true, |n| n as usize > elem.len())
-            || dst.checked_add(len).map_or(true, |m| m > table.size())
+        if src.checked_add(len).is_none_or(|n| n as usize > elem.len())
+            || dst.checked_add(len).is_none_or(|m| m > table.size())
         {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
@@ -635,7 +660,7 @@ impl Instance {
 
         if start_index
             .checked_add(len)
-            .map_or(true, |n| n as usize > table_size)
+            .is_none_or(|n| n as usize > table_size)
         {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
@@ -750,12 +775,10 @@ impl Instance {
         let data = passive_data.get(&data_index).map_or(&[][..], |d| &**d);
 
         let current_length = unsafe { memory.vmmemory().as_ref().current_length };
-        if src
-            .checked_add(len)
-            .map_or(true, |n| n as usize > data.len())
+        if src.checked_add(len).is_none_or(|n| n as usize > data.len())
             || dst
                 .checked_add(len)
-                .map_or(true, |m| usize::try_from(m).unwrap() > current_length)
+                .is_none_or(|m| usize::try_from(m).unwrap() > current_length)
         {
             return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
         }
@@ -805,14 +828,20 @@ impl Instance {
         }
     }
 
-    fn memory_wait(memory: &mut VMMemory, dst: u32, timeout: i64) -> Result<u32, Trap> {
-        let location = NotifyLocation { address: dst };
+    /// # Safety
+    /// See [`LinearMemory::do_wait`].
+    unsafe fn memory_wait(
+        memory: &mut VMMemory,
+        dst: u32,
+        expected: ExpectedValue,
+        timeout: i64,
+    ) -> Result<u32, Trap> {
         let timeout = if timeout < 0 {
             None
         } else {
             Some(std::time::Duration::from_nanos(timeout as u64))
         };
-        match memory.do_wait(location, timeout) {
+        match unsafe { memory.do_wait(dst, expected, timeout) } {
             Ok(count) => Ok(count),
             Err(_err) => {
                 // ret is None if there is more than 2^32 waiter in queue or some other error
@@ -834,12 +863,14 @@ impl Instance {
         // We should trap according to spec, but official test rely on not trapping...
         //}
 
+        // Do a fast-path check of the expected value, and also ensure proper alignment
         let ret = unsafe { memory32_atomic_check32(&memory, dst, val) };
 
         if let Ok(mut ret) = ret {
             if ret == 0 {
                 let memory = self.get_local_vmmemory_mut(memory_index);
-                ret = Self::memory_wait(memory, dst, timeout)?;
+                // Safety: we have already checked alignment and bounds in memory32_atomic_check32
+                ret = unsafe { Self::memory_wait(memory, dst, ExpectedValue::U32(val), timeout)? };
             }
             Ok(ret)
         } else {
@@ -861,11 +892,14 @@ impl Instance {
         // We should trap according to spec, but official test rely on not trapping...
         //}
 
+        // Do a fast-path check of the expected value, and also ensure proper alignment
         let ret = unsafe { memory32_atomic_check32(memory, dst, val) };
+
         if let Ok(mut ret) = ret {
             if ret == 0 {
                 let memory = self.get_vmmemory_mut(memory_index);
-                ret = Self::memory_wait(memory, dst, timeout)?;
+                // Safety: we have already checked alignment and bounds in memory32_atomic_check32
+                ret = unsafe { Self::memory_wait(memory, dst, ExpectedValue::U32(val), timeout)? };
             }
             Ok(ret)
         } else {
@@ -886,12 +920,14 @@ impl Instance {
         // We should trap according to spec, but official test rely on not trapping...
         //}
 
+        // Do a fast-path check of the expected value, and also ensure proper alignment
         let ret = unsafe { memory32_atomic_check64(&memory, dst, val) };
 
         if let Ok(mut ret) = ret {
             if ret == 0 {
                 let memory = self.get_local_vmmemory_mut(memory_index);
-                ret = Self::memory_wait(memory, dst, timeout)?;
+                // Safety: we have already checked alignment and bounds in memory32_atomic_check64
+                ret = unsafe { Self::memory_wait(memory, dst, ExpectedValue::U64(val), timeout)? };
             }
             Ok(ret)
         } else {
@@ -913,12 +949,14 @@ impl Instance {
         // We should trap according to spec, but official test rely on not trapping...
         //}
 
+        // Do a fast-path check of the expected value, and also ensure proper alignment
         let ret = unsafe { memory32_atomic_check64(memory, dst, val) };
 
         if let Ok(mut ret) = ret {
             if ret == 0 {
                 let memory = self.get_vmmemory_mut(memory_index);
-                ret = Self::memory_wait(memory, dst, timeout)?;
+                // Safety: we have already checked alignment and bounds in memory32_atomic_check64
+                ret = unsafe { Self::memory_wait(memory, dst, ExpectedValue::U64(val), timeout)? };
             }
             Ok(ret)
         } else {
@@ -934,9 +972,7 @@ impl Instance {
         count: u32,
     ) -> Result<u32, Trap> {
         let memory = self.get_local_vmmemory_mut(memory_index);
-        // fetch the notifier
-        let location = NotifyLocation { address: dst };
-        Ok(memory.do_notify(location, count))
+        Ok(memory.do_notify(dst, count))
     }
 
     /// Perform an Atomic.Notify
@@ -947,9 +983,7 @@ impl Instance {
         count: u32,
     ) -> Result<u32, Trap> {
         let memory = self.get_vmmemory_mut(memory_index);
-        // fetch the notifier
-        let location = NotifyLocation { address: dst };
-        Ok(memory.do_notify(location, count))
+        Ok(memory.do_notify(dst, count))
     }
 }
 
@@ -991,7 +1025,7 @@ impl Drop for VMInstance {
 }
 
 impl VMInstance {
-    /// Create a new `VMInstance` pointing at a new [`Instance`].
+    /// Create a new `VMInstance` pointing at freshly allocated instance data.
     ///
     /// # Safety
     ///
@@ -1022,110 +1056,124 @@ 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_globals = finished_globals
-            .values()
-            .map(|m| m.get(context).vmglobal())
-            .collect::<PrimaryMap<LocalGlobalIndex, _>>()
-            .into_boxed_slice();
-        let passive_data = RefCell::new(
-            module
-                .passive_data
-                .clone()
-                .into_iter()
-                .map(|(idx, bytes)| (idx, Arc::from(bytes)))
-                .collect::<HashMap<_, _>>(),
-        );
-
-        let handle = {
-            let offsets = allocator.offsets().clone();
-            // use dummy value to create an instance so we can get the vmctx pointer
-            let funcrefs = PrimaryMap::new().into_boxed_slice();
-            let imported_funcrefs = PrimaryMap::new().into_boxed_slice();
-            // Create the `Instance`. The unique, the One.
-            let instance = Instance {
-                module,
-                context,
-                offsets,
-                memories: finished_memories,
-                tables: finished_tables,
-                globals: finished_globals,
-                functions: finished_functions,
-                function_call_trampolines: finished_function_call_trampolines,
-                passive_elements: Default::default(),
-                passive_data,
-                funcrefs,
-                imported_funcrefs,
-                vmctx: VMContext {},
-            };
-
-            let mut instance_handle = allocator.into_vminstance(instance);
-
-            // Set the funcrefs after we've built the instance
-            {
-                let instance = instance_handle.instance_mut();
-                let vmctx_ptr = instance.vmctx_ptr();
-                (instance.funcrefs, instance.imported_funcrefs) = build_funcrefs(
-                    &instance.module,
+        unsafe {
+            let vmctx_tags = tags
+                .values()
+                .map(|m: &InternalStoreHandle<VMTag>| VMSharedTagIndex::new(m.index() as u32))
+                .collect::<PrimaryMap<TagIndex, VMSharedTagIndex>>()
+                .into_boxed_slice();
+            let vmctx_globals = finished_globals
+                .values()
+                .map(|m: &InternalStoreHandle<VMGlobal>| m.get(context).vmglobal())
+                .collect::<PrimaryMap<LocalGlobalIndex, NonNull<VMGlobalDefinition>>>()
+                .into_boxed_slice();
+            let passive_data = RefCell::new(
+                module
+                    .passive_data
+                    .clone()
+                    .into_iter()
+                    .map(|(idx, bytes)| (idx, Arc::from(bytes)))
+                    .collect::<HashMap<_, _>>(),
+            );
+
+            let handle = {
+                let offsets = allocator.offsets().clone();
+                // use dummy value to create an instance so we can get the vmctx pointer
+                let funcrefs = PrimaryMap::new().into_boxed_slice();
+                let imported_funcrefs = PrimaryMap::new().into_boxed_slice();
+                // Create the `Instance`. The unique, the One.
+                let instance = Instance {
+                    module,
                     context,
-                    &imports,
-                    &instance.functions,
-                    &vmshared_signatures,
-                    &instance.function_call_trampolines,
-                    vmctx_ptr,
-                );
-            }
-
-            instance_handle
-        };
-        let instance = handle.instance();
-
-        ptr::copy(
-            vmshared_signatures.values().as_slice().as_ptr(),
-            instance.signature_ids_ptr(),
-            vmshared_signatures.len(),
-        );
-        ptr::copy(
-            imports.functions.values().as_slice().as_ptr(),
-            instance.imported_functions_ptr(),
-            imports.functions.len(),
-        );
-        ptr::copy(
-            imports.tables.values().as_slice().as_ptr(),
-            instance.imported_tables_ptr(),
-            imports.tables.len(),
-        );
-        ptr::copy(
-            imports.memories.values().as_slice().as_ptr(),
-            instance.imported_memories_ptr(),
-            imports.memories.len(),
-        );
-        ptr::copy(
-            imports.globals.values().as_slice().as_ptr(),
-            instance.imported_globals_ptr(),
-            imports.globals.len(),
-        );
-        // these should already be set, add asserts here? for:
-        // - instance.tables_ptr() as *mut VMTableDefinition
-        // - instance.memories_ptr() as *mut VMMemoryDefinition
-        ptr::copy(
-            vmctx_globals.values().as_slice().as_ptr(),
-            instance.globals_ptr() as *mut NonNull<VMGlobalDefinition>,
-            vmctx_globals.len(),
-        );
-        ptr::write(
-            instance.builtin_functions_ptr(),
-            VMBuiltinFunctionsArray::initialized(),
-        );
+                    offsets,
+                    memories: finished_memories,
+                    tables: finished_tables,
+                    tags,
+                    globals: finished_globals,
+                    functions: finished_functions,
+                    function_call_trampolines: finished_function_call_trampolines,
+                    passive_elements: Default::default(),
+                    passive_data,
+                    funcrefs,
+                    imported_funcrefs,
+                    vmctx: VMContext {},
+                };
 
-        // Perform infallible initialization in this constructor, while fallible
-        // initialization is deferred to the `initialize` method.
-        initialize_passive_elements(instance);
-        initialize_globals(instance);
+                let mut instance_handle = allocator.into_vminstance(instance);
+
+                // Set the funcrefs after we've built the instance
+                {
+                    let instance = instance_handle.instance_mut();
+                    let vmctx_ptr = instance.vmctx_ptr();
+                    (instance.funcrefs, instance.imported_funcrefs) = build_funcrefs(
+                        &instance.module,
+                        context,
+                        &imports,
+                        &instance.functions,
+                        &vmshared_signatures,
+                        &instance.function_call_trampolines,
+                        vmctx_ptr,
+                    );
+                }
 
-        Ok(handle)
+                instance_handle
+            };
+            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(),
+                vmshared_signatures.len(),
+            );
+            ptr::copy(
+                imports.functions.values().as_slice().as_ptr(),
+                instance.imported_functions_ptr(),
+                imports.functions.len(),
+            );
+            ptr::copy(
+                imports.tables.values().as_slice().as_ptr(),
+                instance.imported_tables_ptr(),
+                imports.tables.len(),
+            );
+            ptr::copy(
+                imports.memories.values().as_slice().as_ptr(),
+                instance.imported_memories_ptr(),
+                imports.memories.len(),
+            );
+            ptr::copy(
+                imports.globals.values().as_slice().as_ptr(),
+                instance.imported_globals_ptr(),
+                imports.globals.len(),
+            );
+            // these should already be set, add asserts here? for:
+            // - instance.tables_ptr() as *mut VMTableDefinition
+            // - instance.memories_ptr() as *mut VMMemoryDefinition
+            ptr::copy(
+                vmctx_globals.values().as_slice().as_ptr(),
+                instance.globals_ptr() as *mut NonNull<VMGlobalDefinition>,
+                vmctx_globals.len(),
+            );
+            ptr::write(
+                instance.builtin_functions_ptr(),
+                VMBuiltinFunctionsArray::initialized(),
+            );
+
+            // Perform infallible initialization in this constructor, while fallible
+            // initialization is deferred to the `initialize` method.
+            initialize_passive_elements(instance);
+            initialize_globals(instance);
+
+            Ok(handle)
+        }
     }
 
     /// Return a reference to the contained `Instance`.
@@ -1253,6 +1301,11 @@ impl VMInstance {
                 };
                 VMExtern::Global(handle)
             }
+
+            ExportIndex::Tag(index) => {
+                let handle = instance.tags[index];
+                VMExtern::Tag(handle)
+            }
         }
     }
 
@@ -1261,7 +1314,7 @@ impl VMInstance {
     /// Specifically, it provides access to the key-value pairs, where the keys
     /// are export names, and the values are export declarations which can be
     /// resolved `lookup_by_declaration`.
-    pub fn exports(&self) -> indexmap::map::Iter<String, ExportIndex> {
+    pub fn exports(&self) -> indexmap::map::Iter<'_, String, ExportIndex> {
         self.module().exports.iter()
     }
 
@@ -1354,16 +1407,18 @@ unsafe fn get_memory_slice<'instance>(
     init: &DataInitializer<'_>,
     instance: &'instance Instance,
 ) -> &'instance mut [u8] {
-    let memory = if let Some(local_memory_index) = instance
-        .module
-        .local_memory_index(init.location.memory_index)
-    {
-        instance.memory(local_memory_index)
-    } else {
-        let import = instance.imported_memory(init.location.memory_index);
-        *import.definition.as_ref()
-    };
-    slice::from_raw_parts_mut(memory.base, memory.current_length)
+    unsafe {
+        let memory = if let Some(local_memory_index) = instance
+            .module
+            .local_memory_index(init.location.memory_index)
+        {
+            instance.memory(local_memory_index)
+        } else {
+            let import = instance.imported_memory(init.location.memory_index);
+            *import.definition.as_ref()
+        };
+        slice::from_raw_parts_mut(memory.base, memory.current_length)
+    }
 }
 
 /// Compute the offset for a table element initializer.
@@ -1394,19 +1449,30 @@ fn initialize_tables(instance: &mut Instance) -> Result<(), Trap> {
 
         if start
             .checked_add(init.elements.len())
-            .map_or(true, |end| end > table.size() as usize)
+            .is_none_or(|end| end > table.size() as usize)
         {
             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();
+            }
         }
     }
 
@@ -1423,19 +1489,21 @@ fn initialize_passive_elements(instance: &Instance) {
         "should only be called once, at initialization time"
     );
 
-    passive_elements.extend(
-        instance
-            .module
-            .passive_elements
-            .iter()
-            .filter(|(_, segments)| !segments.is_empty())
-            .map(|(idx, segments)| {
-                (
-                    *idx,
-                    segments.iter().map(|s| instance.func_ref(*s)).collect(),
-                )
-            }),
-    );
+    passive_elements.extend(instance.module.passive_elements.iter().filter_map(
+        |(&idx, segments)| -> Option<(ElemIndex, Box<[Option<VMFuncRef>]>)> {
+            if segments.is_empty() {
+                None
+            } else {
+                Some((
+                    idx,
+                    segments
+                        .iter()
+                        .map(|s| instance.func_ref(*s))
+                        .collect::<Box<[Option<VMFuncRef>]>>(),
+                ))
+            }
+        },
+    ));
 }
 
 /// Initialize the table memory from the provided initializers.
@@ -1451,7 +1519,7 @@ fn initialize_memories(
             let current_length = memory.vmmemory().as_ref().current_length;
             if start
                 .checked_add(init.data.len())
-                .map_or(true, |end| end > current_length)
+                .is_none_or(|end| end > current_length)
             {
                 return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
             }
diff --git a/lib/vm/src/lib.rs b/lib/vm/src/lib.rs
index 726e304b8b..2e7f19bb59 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,
@@ -13,8 +12,9 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
+mod exception;
 mod export;
 mod extern_ref;
 mod function_env;
@@ -35,6 +35,7 @@ pub mod libcalls;
 
 use std::ptr::NonNull;
 
+pub use crate::exception::{VMExceptionObj, VMExceptionRef};
 pub use crate::export::*;
 pub use crate::extern_ref::{VMExternObj, VMExternRef};
 pub use crate::function_env::VMFunctionEnvironment;
@@ -42,8 +43,8 @@ pub use crate::global::*;
 pub use crate::imports::Imports;
 pub use crate::instance::{InstanceAllocator, VMInstance};
 pub use crate::memory::{
-    initialize_memory_with_data, LinearMemory, NotifyLocation, VMMemory, VMOwnedMemory,
-    VMSharedMemory,
+    LinearMemory, NotifyLocation, VMMemory, VMOwnedMemory, VMSharedMemory,
+    initialize_memory_with_data,
 };
 pub use crate::mmap::{Mmap, MmapType};
 pub use crate::probestack::PROBESTACK;
@@ -51,13 +52,17 @@ pub use crate::sig_registry::SignatureRegistry;
 pub use crate::store::{InternalStoreHandle, MaybeInstanceOwned, StoreHandle, StoreObjects};
 pub use crate::table::{TableElement, VMTable};
 #[doc(hidden)]
-pub use crate::threadconditions::{ThreadConditions, ThreadConditionsHandle, WaiterError};
+pub use crate::threadconditions::{
+    ExpectedValue, ThreadConditions, ThreadConditionsHandle, WaiterError,
+};
 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 +95,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);
 
@@ -128,7 +134,7 @@ impl VMFuncRef {
     /// # Safety
     /// `raw.funcref` must be a valid pointer.
     pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
-        NonNull::new(raw.funcref as *mut VMCallerCheckedAnyfunc).map(Self)
+        unsafe { NonNull::new(raw.funcref as *mut VMCallerCheckedAnyfunc).map(Self) }
     }
 }
 
diff --git a/lib/vm/src/libcalls.rs b/lib/vm/src/libcalls.rs
index 04a2a9a1b7..d4497086d6 100644
--- a/lib/vm/src/libcalls.rs
+++ b/lib/vm/src/libcalls.rs
@@ -37,38 +37,45 @@
 
 #![allow(missing_docs)] // For some reason lint fails saying that `LibCall` is not documented, when it actually is
 
-use crate::probestack::PROBESTACK;
-use crate::table::{RawTableElement, TableElement};
-use crate::trap::{raise_lib_trap, Trap, TrapCode};
+use std::{ffi::c_void, panic};
+mod eh;
+
+use crate::trap::{Trap, TrapCode, raise_lib_trap};
 use crate::vmcontext::VMContext;
-use crate::{on_host_stack, VMFuncRef};
+use crate::{
+    InternalStoreHandle,
+    table::{RawTableElement, TableElement},
+};
+use crate::{VMExceptionObj, probestack::PROBESTACK};
+use crate::{VMFuncRef, on_host_stack};
+pub use eh::{throw, wasmer_eh_personality, wasmer_eh_personality2};
 pub use wasmer_types::LibCall;
 use wasmer_types::{
-    DataIndex, ElemIndex, FunctionIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
-    TableIndex, Type,
+    DataIndex, ElemIndex, FunctionIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, RawValue,
+    TableIndex, TagIndex, Type,
 };
 
 /// Implementation of f32.ceil
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f32_ceil(x: f32) -> f32 {
     x.ceil()
 }
 
 /// Implementation of f32.floor
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f32_floor(x: f32) -> f32 {
     x.floor()
 }
 
 /// Implementation of f32.trunc
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f32_trunc(x: f32) -> f32 {
     x.trunc()
 }
 
 /// Implementation of f32.nearest
 #[allow(clippy::float_arithmetic, clippy::float_cmp)]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f32_nearest(x: f32) -> f32 {
     // Rust doesn't have a nearest function, so do it manually.
     if x == 0.0 {
@@ -94,26 +101,26 @@ pub extern "C" fn wasmer_vm_f32_nearest(x: f32) -> f32 {
 }
 
 /// Implementation of f64.ceil
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f64_ceil(x: f64) -> f64 {
     x.ceil()
 }
 
 /// Implementation of f64.floor
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f64_floor(x: f64) -> f64 {
     x.floor()
 }
 
 /// Implementation of f64.trunc
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f64_trunc(x: f64) -> f64 {
     x.trunc()
 }
 
 /// Implementation of f64.nearest
 #[allow(clippy::float_arithmetic, clippy::float_cmp)]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasmer_vm_f64_nearest(x: f64) -> f64 {
     // Rust doesn't have a nearest function, so do it manually.
     if x == 0.0 {
@@ -143,21 +150,23 @@ pub extern "C" fn wasmer_vm_f64_nearest(x: f64) -> f64 {
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_grow(
     vmctx: *mut VMContext,
     delta: u32,
     memory_index: u32,
 ) -> u32 {
-    on_host_stack(|| {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
-
-        instance
-            .memory_grow(memory_index, delta)
-            .map(|pages| pages.0)
-            .unwrap_or(u32::max_value())
-    })
+    unsafe {
+        on_host_stack(|| {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+            instance
+                .memory_grow(memory_index, delta)
+                .map(|pages| pages.0)
+                .unwrap_or(u32::MAX)
+        })
+    }
 }
 
 /// Implementation of memory.grow for imported 32-bit memories.
@@ -165,21 +174,23 @@ pub unsafe extern "C" fn wasmer_vm_memory32_grow(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_grow(
     vmctx: *mut VMContext,
     delta: u32,
     memory_index: u32,
 ) -> u32 {
-    on_host_stack(|| {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = MemoryIndex::from_u32(memory_index);
-
-        instance
-            .imported_memory_grow(memory_index, delta)
-            .map(|pages| pages.0)
-            .unwrap_or(u32::max_value())
-    })
+    unsafe {
+        on_host_stack(|| {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = MemoryIndex::from_u32(memory_index);
+
+            instance
+                .imported_memory_grow(memory_index, delta)
+                .map(|pages| pages.0)
+                .unwrap_or(u32::MAX)
+        })
+    }
 }
 
 /// Implementation of memory.size for locally-defined 32-bit memories.
@@ -187,12 +198,14 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_grow(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_size(vmctx: *mut VMContext, memory_index: u32) -> u32 {
-    let instance = (*vmctx).instance();
-    let memory_index = LocalMemoryIndex::from_u32(memory_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
 
-    instance.memory_size(memory_index).0
+        instance.memory_size(memory_index).0
+    }
 }
 
 /// Implementation of memory.size for imported 32-bit memories.
@@ -200,15 +213,17 @@ pub unsafe extern "C" fn wasmer_vm_memory32_size(vmctx: *mut VMContext, memory_i
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_size(
     vmctx: *mut VMContext,
     memory_index: u32,
 ) -> u32 {
-    let instance = (*vmctx).instance();
-    let memory_index = MemoryIndex::from_u32(memory_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let memory_index = MemoryIndex::from_u32(memory_index);
 
-    instance.imported_memory_size(memory_index).0
+        instance.imported_memory_size(memory_index).0
+    }
 }
 
 /// Implementation of `table.copy`.
@@ -216,7 +231,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_size(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_copy(
     vmctx: *mut VMContext,
     dst_table_index: u32,
@@ -225,20 +240,22 @@ pub unsafe extern "C" fn wasmer_vm_table_copy(
     src: u32,
     len: u32,
 ) {
-    let result = {
-        let dst_table_index = TableIndex::from_u32(dst_table_index);
-        let src_table_index = TableIndex::from_u32(src_table_index);
-        if dst_table_index == src_table_index {
-            let table = (*vmctx).instance_mut().get_table(dst_table_index);
-            table.copy_within(dst, src, len)
-        } else {
-            let dst_table = (*vmctx).instance_mut().get_table(dst_table_index);
-            let src_table = (*vmctx).instance_mut().get_table(src_table_index);
-            dst_table.copy(src_table, dst, src, len)
+    unsafe {
+        let result = {
+            let dst_table_index = TableIndex::from_u32(dst_table_index);
+            let src_table_index = TableIndex::from_u32(src_table_index);
+            if dst_table_index == src_table_index {
+                let table = (*vmctx).instance_mut().get_table(dst_table_index);
+                table.copy_within(dst, src, len)
+            } else {
+                let dst_table = (*vmctx).instance_mut().get_table(dst_table_index);
+                let src_table = (*vmctx).instance_mut().get_table(src_table_index);
+                dst_table.copy(src_table, dst, src, len)
+            }
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
         }
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
     }
 }
 
@@ -247,7 +264,7 @@ pub unsafe extern "C" fn wasmer_vm_table_copy(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_init(
     vmctx: *mut VMContext,
     table_index: u32,
@@ -256,14 +273,16 @@ pub unsafe extern "C" fn wasmer_vm_table_init(
     src: u32,
     len: u32,
 ) {
-    let result = {
-        let table_index = TableIndex::from_u32(table_index);
-        let elem_index = ElemIndex::from_u32(elem_index);
-        let instance = (*vmctx).instance_mut();
-        instance.table_init(table_index, elem_index, dst, src, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let table_index = TableIndex::from_u32(table_index);
+            let elem_index = ElemIndex::from_u32(elem_index);
+            let instance = (*vmctx).instance_mut();
+            instance.table_init(table_index, elem_index, dst, src, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -272,7 +291,7 @@ pub unsafe extern "C" fn wasmer_vm_table_init(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_fill(
     vmctx: *mut VMContext,
     table_index: u32,
@@ -280,19 +299,21 @@ pub unsafe extern "C" fn wasmer_vm_table_fill(
     item: RawTableElement,
     len: u32,
 ) {
-    let result = {
-        let table_index = TableIndex::from_u32(table_index);
-        let instance = (*vmctx).instance_mut();
-        let elem = match instance.get_table(table_index).ty().ty {
-            Type::ExternRef => TableElement::ExternRef(item.extern_ref),
-            Type::FuncRef => TableElement::FuncRef(item.func_ref),
-            _ => panic!("Unrecognized table type: does not contain references"),
+    unsafe {
+        let result = {
+            let table_index = TableIndex::from_u32(table_index);
+            let instance = (*vmctx).instance_mut();
+            let elem = match instance.get_table(table_index).ty().ty {
+                Type::ExternRef => TableElement::ExternRef(item.extern_ref),
+                Type::FuncRef => TableElement::FuncRef(item.func_ref),
+                _ => panic!("Unrecognized table type: does not contain references"),
+            };
+
+            instance.table_fill(table_index, start_idx, elem, len)
         };
-
-        instance.table_fill(table_index, start_idx, elem, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -301,12 +322,14 @@ pub unsafe extern "C" fn wasmer_vm_table_fill(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_size(vmctx: *mut VMContext, table_index: u32) -> u32 {
-    let instance = (*vmctx).instance();
-    let table_index = LocalTableIndex::from_u32(table_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let table_index = LocalTableIndex::from_u32(table_index);
 
-    instance.table_size(table_index)
+        instance.table_size(table_index)
+    }
 }
 
 /// Implementation of `table.size` for imported tables.
@@ -314,15 +337,17 @@ pub unsafe extern "C" fn wasmer_vm_table_size(vmctx: *mut VMContext, table_index
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_table_size(
     vmctx: *mut VMContext,
     table_index: u32,
 ) -> u32 {
-    let instance = (*vmctx).instance();
-    let table_index = TableIndex::from_u32(table_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let table_index = TableIndex::from_u32(table_index);
 
-    instance.imported_table_size(table_index)
+        instance.imported_table_size(table_index)
+    }
 }
 
 /// Implementation of `table.get`.
@@ -330,19 +355,21 @@ pub unsafe extern "C" fn wasmer_vm_imported_table_size(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_get(
     vmctx: *mut VMContext,
     table_index: u32,
     elem_index: u32,
 ) -> RawTableElement {
-    let instance = (*vmctx).instance();
-    let table_index = LocalTableIndex::from_u32(table_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let table_index = LocalTableIndex::from_u32(table_index);
 
-    // TODO: type checking, maybe have specialized accessors
-    match instance.table_get(table_index, elem_index) {
-        Some(table_ref) => table_ref.into(),
-        None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+        // TODO: type checking, maybe have specialized accessors
+        match instance.table_get(table_index, elem_index) {
+            Some(table_ref) => table_ref.into(),
+            None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+        }
     }
 }
 
@@ -351,19 +378,21 @@ pub unsafe extern "C" fn wasmer_vm_table_get(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_table_get(
     vmctx: *mut VMContext,
     table_index: u32,
     elem_index: u32,
 ) -> RawTableElement {
-    let instance = (*vmctx).instance_mut();
-    let table_index = TableIndex::from_u32(table_index);
+    unsafe {
+        let instance = (*vmctx).instance_mut();
+        let table_index = TableIndex::from_u32(table_index);
 
-    // TODO: type checking, maybe have specialized accessors
-    match instance.imported_table_get(table_index, elem_index) {
-        Some(table_ref) => table_ref.into(),
-        None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+        // TODO: type checking, maybe have specialized accessors
+        match instance.imported_table_get(table_index, elem_index) {
+            Some(table_ref) => table_ref.into(),
+            None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+        }
     }
 }
 
@@ -375,31 +404,33 @@ pub unsafe extern "C" fn wasmer_vm_imported_table_get(
 ///
 /// It is the caller's responsibility to increment the ref count of any ref counted
 /// type before passing it to this function.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_set(
     vmctx: *mut VMContext,
     table_index: u32,
     elem_index: u32,
     value: RawTableElement,
 ) {
-    let instance = (*vmctx).instance_mut();
-    let table_index = TableIndex::from_u32(table_index);
-    let table_index = instance
-        .module_ref()
-        .local_table_index(table_index)
-        .unwrap();
-
-    let elem = match instance.get_local_table(table_index).ty().ty {
-        Type::ExternRef => TableElement::ExternRef(value.extern_ref),
-        Type::FuncRef => TableElement::FuncRef(value.func_ref),
-        _ => panic!("Unrecognized table type: does not contain references"),
-    };
+    unsafe {
+        let instance = (*vmctx).instance_mut();
+        let table_index = TableIndex::from_u32(table_index);
+        let table_index = instance
+            .module_ref()
+            .local_table_index(table_index)
+            .unwrap();
+
+        let elem = match instance.get_local_table(table_index).ty().ty {
+            Type::ExternRef => TableElement::ExternRef(value.extern_ref),
+            Type::FuncRef => TableElement::FuncRef(value.func_ref),
+            _ => panic!("Unrecognized table type: does not contain references"),
+        };
 
-    // TODO: type checking, maybe have specialized accessors
-    let result = instance.table_set(table_index, elem_index, elem);
+        // TODO: type checking, maybe have specialized accessors
+        let result = instance.table_set(table_index, elem_index, elem);
 
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -408,25 +439,27 @@ pub unsafe extern "C" fn wasmer_vm_table_set(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_table_set(
     vmctx: *mut VMContext,
     table_index: u32,
     elem_index: u32,
     value: RawTableElement,
 ) {
-    let instance = (*vmctx).instance_mut();
-    let table_index = TableIndex::from_u32(table_index);
-    let elem = match instance.get_table(table_index).ty().ty {
-        Type::ExternRef => TableElement::ExternRef(value.extern_ref),
-        Type::FuncRef => TableElement::FuncRef(value.func_ref),
-        _ => panic!("Unrecognized table type: does not contain references"),
-    };
+    unsafe {
+        let instance = (*vmctx).instance_mut();
+        let table_index = TableIndex::from_u32(table_index);
+        let elem = match instance.get_table(table_index).ty().ty {
+            Type::ExternRef => TableElement::ExternRef(value.extern_ref),
+            Type::FuncRef => TableElement::FuncRef(value.func_ref),
+            _ => panic!("Unrecognized table type: does not contain references"),
+        };
 
-    let result = instance.imported_table_set(table_index, elem_index, elem);
+        let result = instance.imported_table_set(table_index, elem_index, elem);
 
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -435,27 +468,29 @@ pub unsafe extern "C" fn wasmer_vm_imported_table_set(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_table_grow(
     vmctx: *mut VMContext,
     init_value: RawTableElement,
     delta: u32,
     table_index: u32,
 ) -> u32 {
-    on_host_stack(|| {
-        let instance = (*vmctx).instance_mut();
-        let table_index = LocalTableIndex::from_u32(table_index);
-
-        let init_value = match instance.get_local_table(table_index).ty().ty {
-            Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
-            Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
-            _ => panic!("Unrecognized table type: does not contain references"),
-        };
-
-        instance
-            .table_grow(table_index, delta, init_value)
-            .unwrap_or(u32::max_value())
-    })
+    unsafe {
+        on_host_stack(|| {
+            let instance = (*vmctx).instance_mut();
+            let table_index = LocalTableIndex::from_u32(table_index);
+
+            let init_value = match instance.get_local_table(table_index).ty().ty {
+                Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
+                Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
+                _ => panic!("Unrecognized table type: does not contain references"),
+            };
+
+            instance
+                .table_grow(table_index, delta, init_value)
+                .unwrap_or(u32::MAX)
+        })
+    }
 }
 
 /// Implementation of `table.grow` for imported tables.
@@ -463,26 +498,28 @@ pub unsafe extern "C" fn wasmer_vm_table_grow(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_table_grow(
     vmctx: *mut VMContext,
     init_value: RawTableElement,
     delta: u32,
     table_index: u32,
 ) -> u32 {
-    on_host_stack(|| {
-        let instance = (*vmctx).instance_mut();
-        let table_index = TableIndex::from_u32(table_index);
-        let init_value = match instance.get_table(table_index).ty().ty {
-            Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
-            Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
-            _ => panic!("Unrecognized table type: does not contain references"),
-        };
-
-        instance
-            .imported_table_grow(table_index, delta, init_value)
-            .unwrap_or(u32::max_value())
-    })
+    unsafe {
+        on_host_stack(|| {
+            let instance = (*vmctx).instance_mut();
+            let table_index = TableIndex::from_u32(table_index);
+            let init_value = match instance.get_table(table_index).ty().ty {
+                Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
+                Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
+                _ => panic!("Unrecognized table type: does not contain references"),
+            };
+
+            instance
+                .imported_table_grow(table_index, delta, init_value)
+                .unwrap_or(u32::MAX)
+        })
+    }
 }
 
 /// Implementation of `func.ref`.
@@ -490,15 +527,17 @@ pub unsafe extern "C" fn wasmer_vm_imported_table_grow(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_func_ref(
     vmctx: *mut VMContext,
     function_index: u32,
 ) -> VMFuncRef {
-    let instance = (*vmctx).instance();
-    let function_index = FunctionIndex::from_u32(function_index);
+    unsafe {
+        let instance = (*vmctx).instance();
+        let function_index = FunctionIndex::from_u32(function_index);
 
-    instance.func_ref(function_index).unwrap()
+        instance.func_ref(function_index).unwrap()
+    }
 }
 
 /// Implementation of `elem.drop`.
@@ -506,13 +545,15 @@ pub unsafe extern "C" fn wasmer_vm_func_ref(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_elem_drop(vmctx: *mut VMContext, elem_index: u32) {
-    on_host_stack(|| {
-        let elem_index = ElemIndex::from_u32(elem_index);
-        let instance = (*vmctx).instance();
-        instance.elem_drop(elem_index);
-    })
+    unsafe {
+        on_host_stack(|| {
+            let elem_index = ElemIndex::from_u32(elem_index);
+            let instance = (*vmctx).instance();
+            instance.elem_drop(elem_index);
+        })
+    }
 }
 
 /// Implementation of `memory.copy` for locally defined memories.
@@ -520,7 +561,7 @@ pub unsafe extern "C" fn wasmer_vm_elem_drop(vmctx: *mut VMContext, elem_index:
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_copy(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -528,13 +569,15 @@ pub unsafe extern "C" fn wasmer_vm_memory32_copy(
     src: u32,
     len: u32,
 ) {
-    let result = {
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
-        let instance = (*vmctx).instance();
-        instance.local_memory_copy(memory_index, dst, src, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
+            let instance = (*vmctx).instance();
+            instance.local_memory_copy(memory_index, dst, src, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -543,7 +586,7 @@ pub unsafe extern "C" fn wasmer_vm_memory32_copy(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_copy(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -551,13 +594,15 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_copy(
     src: u32,
     len: u32,
 ) {
-    let result = {
-        let memory_index = MemoryIndex::from_u32(memory_index);
-        let instance = (*vmctx).instance();
-        instance.imported_memory_copy(memory_index, dst, src, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let memory_index = MemoryIndex::from_u32(memory_index);
+            let instance = (*vmctx).instance();
+            instance.imported_memory_copy(memory_index, dst, src, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -566,7 +611,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_copy(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_fill(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -574,13 +619,15 @@ pub unsafe extern "C" fn wasmer_vm_memory32_fill(
     val: u32,
     len: u32,
 ) {
-    let result = {
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
-        let instance = (*vmctx).instance();
-        instance.local_memory_fill(memory_index, dst, val, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
+            let instance = (*vmctx).instance();
+            instance.local_memory_fill(memory_index, dst, val, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -589,7 +636,7 @@ pub unsafe extern "C" fn wasmer_vm_memory32_fill(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_fill(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -597,13 +644,15 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_fill(
     val: u32,
     len: u32,
 ) {
-    let result = {
-        let memory_index = MemoryIndex::from_u32(memory_index);
-        let instance = (*vmctx).instance();
-        instance.imported_memory_fill(memory_index, dst, val, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let memory_index = MemoryIndex::from_u32(memory_index);
+            let instance = (*vmctx).instance();
+            instance.imported_memory_fill(memory_index, dst, val, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -612,7 +661,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_fill(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_init(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -621,14 +670,16 @@ pub unsafe extern "C" fn wasmer_vm_memory32_init(
     src: u32,
     len: u32,
 ) {
-    let result = {
-        let memory_index = MemoryIndex::from_u32(memory_index);
-        let data_index = DataIndex::from_u32(data_index);
-        let instance = (*vmctx).instance();
-        instance.memory_init(memory_index, data_index, dst, src, len)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+    unsafe {
+        let result = {
+            let memory_index = MemoryIndex::from_u32(memory_index);
+            let data_index = DataIndex::from_u32(data_index);
+            let instance = (*vmctx).instance();
+            instance.memory_init(memory_index, data_index, dst, src, len)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
     }
 }
 
@@ -637,13 +688,15 @@ pub unsafe extern "C" fn wasmer_vm_memory32_init(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_data_drop(vmctx: *mut VMContext, data_index: u32) {
-    on_host_stack(|| {
-        let data_index = DataIndex::from_u32(data_index);
-        let instance = (*vmctx).instance();
-        instance.data_drop(data_index)
-    })
+    unsafe {
+        on_host_stack(|| {
+            let data_index = DataIndex::from_u32(data_index);
+            let instance = (*vmctx).instance();
+            instance.data_drop(data_index)
+        })
+    }
 }
 
 /// Implementation for raising a trap
@@ -652,10 +705,87 @@ pub unsafe extern "C" fn wasmer_vm_data_drop(vmctx: *mut VMContext, data_index:
 ///
 /// Only safe to call when wasm code is on the stack, aka `wasmer_call` or
 /// `wasmer_call_trampoline` must have been previously called.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_raise_trap(trap_code: TrapCode) -> ! {
-    let trap = Trap::lib(trap_code);
-    raise_lib_trap(trap)
+    unsafe {
+        let trap = Trap::lib(trap_code);
+        raise_lib_trap(trap)
+    }
+}
+
+/// (debug) Print an usize.
+#[unsafe(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.
+#[unsafe(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 throwing an exception.
+///
+/// # Safety
+///
+/// Calls libunwind to perform unwinding magic.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn wasmer_vm_throw(vmctx: *mut VMContext, exnref: u32) -> ! {
+    let instance = unsafe { (*vmctx).instance() };
+    unsafe { eh::throw(instance.context(), exnref) }
+}
+
+/// Implementation for allocating an exception. Returns the exnref, i.e. a handle to the
+/// exception within the store.
+///
+/// # Safety
+///
+/// The vmctx pointer must be dereferenceable.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn wasmer_vm_alloc_exception(vmctx: *mut VMContext, tag: u32) -> u32 {
+    let instance = unsafe { (*vmctx).instance_mut() };
+    let unique_tag = instance.shared_tag_ptr(TagIndex::from_u32(tag)).index();
+    let exn = VMExceptionObj::new_zeroed(
+        instance.context(),
+        InternalStoreHandle::from_index(unique_tag as usize).unwrap(),
+    );
+    let exnref = InternalStoreHandle::new(instance.context_mut(), exn);
+    exnref.index() as u32
+}
+
+/// Given a VMContext and an exnref (handle to an exception within the store),
+/// returns a pointer to the payload buffer of the underlying VMExceptionObj.
+#[unsafe(no_mangle)]
+pub extern "C-unwind" fn wasmer_vm_read_exnref(
+    vmctx: *mut VMContext,
+    exnref: u32,
+) -> *mut RawValue {
+    let exn = eh::exn_obj_from_exnref(vmctx, exnref);
+    unsafe { (*exn).payload().as_ptr() as *mut RawValue }
+}
+
+/// Given a pointer to a caught exception, return the exnref contained within.
+///
+/// # Safety
+///
+/// `exception` must be a pointer the platform-specific exception type; this is
+/// `UwExceptionWrapper` for gcc.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn wasmer_vm_exception_into_exnref(exception: *mut c_void) -> u32 {
+    unsafe {
+        let exnref = eh::read_exnref(exception);
+        eh::delete_exception(exception);
+        exnref
+    }
 }
 
 /// Probestack check
@@ -664,15 +794,15 @@ 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;
+#[unsafe(no_mangle)]
+pub static WASMER_VM_PROBESTACK: unsafe extern "C" fn() = PROBESTACK;
 
 /// Implementation of memory.wait32 for locally-defined 32-bit memories.
 ///
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait32(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -680,16 +810,18 @@ pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait32(
     val: u32,
     timeout: i64,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
 
-        instance.local_memory_wait32(memory_index, dst, val, timeout)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.local_memory_wait32(memory_index, dst, val, timeout)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
 /// Implementation of memory.wait32 for imported 32-bit memories.
@@ -697,7 +829,7 @@ pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait32(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait32(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -705,16 +837,18 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait32(
     val: u32,
     timeout: i64,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = MemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = MemoryIndex::from_u32(memory_index);
 
-        instance.imported_memory_wait32(memory_index, dst, val, timeout)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.imported_memory_wait32(memory_index, dst, val, timeout)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
 /// Implementation of memory.wait64 for locally-defined 32-bit memories.
@@ -722,7 +856,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait32(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait64(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -730,16 +864,18 @@ pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait64(
     val: u64,
     timeout: i64,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
 
-        instance.local_memory_wait64(memory_index, dst, val, timeout)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.local_memory_wait64(memory_index, dst, val, timeout)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
 /// Implementation of memory.wait64 for imported 32-bit memories.
@@ -747,7 +883,7 @@ pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait64(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait64(
     vmctx: *mut VMContext,
     memory_index: u32,
@@ -755,40 +891,44 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait64(
     val: u64,
     timeout: i64,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = MemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = MemoryIndex::from_u32(memory_index);
 
-        instance.imported_memory_wait64(memory_index, dst, val, timeout)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.imported_memory_wait64(memory_index, dst, val, timeout)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
-/// Implementation of memory.notfy for locally-defined 32-bit memories.
+/// Implementation of memory.notify for locally-defined 32-bit memories.
 ///
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_memory32_atomic_notify(
     vmctx: *mut VMContext,
     memory_index: u32,
     dst: u32,
     cnt: u32,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = LocalMemoryIndex::from_u32(memory_index);
 
-        instance.local_memory_notify(memory_index, dst, cnt)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.local_memory_notify(memory_index, dst, cnt)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
 /// Implementation of memory.notfy for imported 32-bit memories.
@@ -796,64 +936,82 @@ pub unsafe extern "C" fn wasmer_vm_memory32_atomic_notify(
 /// # Safety
 ///
 /// `vmctx` must be dereferenceable.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_notify(
     vmctx: *mut VMContext,
     memory_index: u32,
     dst: u32,
     cnt: u32,
 ) -> u32 {
-    let result = {
-        let instance = (*vmctx).instance_mut();
-        let memory_index = MemoryIndex::from_u32(memory_index);
+    unsafe {
+        let result = {
+            let instance = (*vmctx).instance_mut();
+            let memory_index = MemoryIndex::from_u32(memory_index);
 
-        instance.imported_memory_notify(memory_index, dst, cnt)
-    };
-    if let Err(trap) = result {
-        raise_lib_trap(trap);
+            instance.imported_memory_notify(memory_index, dst, cnt)
+        };
+        if let Err(trap) = result {
+            raise_lib_trap(trap);
+        }
+        result.unwrap()
     }
-    result.unwrap()
 }
 
 /// The function pointer to a libcall
 pub fn function_pointer(libcall: LibCall) -> usize {
     match libcall {
-        LibCall::CeilF32 => wasmer_vm_f32_ceil as usize,
-        LibCall::CeilF64 => wasmer_vm_f64_ceil as usize,
-        LibCall::FloorF32 => wasmer_vm_f32_floor as usize,
-        LibCall::FloorF64 => wasmer_vm_f64_floor as usize,
-        LibCall::NearestF32 => wasmer_vm_f32_nearest as usize,
-        LibCall::NearestF64 => wasmer_vm_f64_nearest as usize,
-        LibCall::TruncF32 => wasmer_vm_f32_trunc as usize,
-        LibCall::TruncF64 => wasmer_vm_f64_trunc as usize,
-        LibCall::Memory32Size => wasmer_vm_memory32_size as usize,
-        LibCall::ImportedMemory32Size => wasmer_vm_imported_memory32_size as usize,
-        LibCall::TableCopy => wasmer_vm_table_copy as usize,
-        LibCall::TableInit => wasmer_vm_table_init as usize,
-        LibCall::TableFill => wasmer_vm_table_fill as usize,
-        LibCall::TableSize => wasmer_vm_table_size as usize,
-        LibCall::ImportedTableSize => wasmer_vm_imported_table_size as usize,
-        LibCall::TableGet => wasmer_vm_table_get as usize,
-        LibCall::ImportedTableGet => wasmer_vm_imported_table_get as usize,
-        LibCall::TableSet => wasmer_vm_table_set as usize,
-        LibCall::ImportedTableSet => wasmer_vm_imported_table_set as usize,
-        LibCall::TableGrow => wasmer_vm_table_grow as usize,
-        LibCall::ImportedTableGrow => wasmer_vm_imported_table_grow as usize,
-        LibCall::FuncRef => wasmer_vm_func_ref as usize,
-        LibCall::ElemDrop => wasmer_vm_elem_drop as usize,
-        LibCall::Memory32Copy => wasmer_vm_memory32_copy as usize,
-        LibCall::ImportedMemory32Copy => wasmer_vm_imported_memory32_copy as usize,
-        LibCall::Memory32Fill => wasmer_vm_memory32_fill as 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::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,
-        LibCall::Memory32AtomicWait64 => wasmer_vm_memory32_atomic_wait64 as 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::CeilF32 => wasmer_vm_f32_ceil as *const () as usize,
+        LibCall::CeilF64 => wasmer_vm_f64_ceil as *const () as usize,
+        LibCall::FloorF32 => wasmer_vm_f32_floor as *const () as usize,
+        LibCall::FloorF64 => wasmer_vm_f64_floor as *const () as usize,
+        LibCall::NearestF32 => wasmer_vm_f32_nearest as *const () as usize,
+        LibCall::NearestF64 => wasmer_vm_f64_nearest as *const () as usize,
+        LibCall::TruncF32 => wasmer_vm_f32_trunc as *const () as usize,
+        LibCall::TruncF64 => wasmer_vm_f64_trunc as *const () as usize,
+        LibCall::Memory32Size => wasmer_vm_memory32_size as *const () as usize,
+        LibCall::ImportedMemory32Size => wasmer_vm_imported_memory32_size as *const () as usize,
+        LibCall::TableCopy => wasmer_vm_table_copy as *const () as usize,
+        LibCall::TableInit => wasmer_vm_table_init as *const () as usize,
+        LibCall::TableFill => wasmer_vm_table_fill as *const () as usize,
+        LibCall::TableSize => wasmer_vm_table_size as *const () as usize,
+        LibCall::ImportedTableSize => wasmer_vm_imported_table_size as *const () as usize,
+        LibCall::TableGet => wasmer_vm_table_get as *const () as usize,
+        LibCall::ImportedTableGet => wasmer_vm_imported_table_get as *const () as usize,
+        LibCall::TableSet => wasmer_vm_table_set as *const () as usize,
+        LibCall::ImportedTableSet => wasmer_vm_imported_table_set as *const () as usize,
+        LibCall::TableGrow => wasmer_vm_table_grow as *const () as usize,
+        LibCall::ImportedTableGrow => wasmer_vm_imported_table_grow as *const () as usize,
+        LibCall::FuncRef => wasmer_vm_func_ref as *const () as usize,
+        LibCall::ElemDrop => wasmer_vm_elem_drop as *const () as usize,
+        LibCall::Memory32Copy => wasmer_vm_memory32_copy as *const () as usize,
+        LibCall::ImportedMemory32Copy => wasmer_vm_imported_memory32_copy as *const () as usize,
+        LibCall::Memory32Fill => wasmer_vm_memory32_fill as *const () as usize,
+        LibCall::ImportedMemory32Fill => wasmer_vm_imported_memory32_fill as *const () as usize,
+        LibCall::Memory32Init => wasmer_vm_memory32_init as *const () as usize,
+        LibCall::DataDrop => wasmer_vm_data_drop as *const () as usize,
+        LibCall::Probestack => WASMER_VM_PROBESTACK as *const () as usize,
+        LibCall::RaiseTrap => wasmer_vm_raise_trap as *const () as usize,
+        LibCall::Memory32AtomicWait32 => wasmer_vm_memory32_atomic_wait32 as *const () as usize,
+        LibCall::ImportedMemory32AtomicWait32 => {
+            wasmer_vm_imported_memory32_atomic_wait32 as *const () as usize
+        }
+        LibCall::Memory32AtomicWait64 => wasmer_vm_memory32_atomic_wait64 as *const () as usize,
+        LibCall::ImportedMemory32AtomicWait64 => {
+            wasmer_vm_imported_memory32_atomic_wait64 as *const () as usize
+        }
+        LibCall::Memory32AtomicNotify => wasmer_vm_memory32_atomic_notify as *const () as usize,
+        LibCall::ImportedMemory32AtomicNotify => {
+            wasmer_vm_imported_memory32_atomic_notify as *const () as usize
+        }
+        LibCall::Throw => wasmer_vm_throw as *const () as usize,
+        LibCall::EHPersonality => eh::wasmer_eh_personality as *const () as usize,
+        LibCall::EHPersonality2 => eh::wasmer_eh_personality2 as *const () as usize,
+        LibCall::AllocException => wasmer_vm_alloc_exception as *const () as usize,
+        LibCall::ReadExnRef => wasmer_vm_read_exnref as *const () as usize,
+        LibCall::LibunwindExceptionIntoExnRef => {
+            wasmer_vm_exception_into_exnref as *const () as usize
+        }
+        LibCall::DebugUsize => wasmer_vm_dbg_usize as *const () as usize,
+        LibCall::DebugStr => wasmer_vm_dbg_str as *const () 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..8ded2c4010
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/dwarf/eh.rs
@@ -0,0 +1,435 @@
+//! 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 gimli::DwEhPe;
+
+use super::DwarfReader;
+
+#[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_start_encoding = unsafe { DwEhPe(reader.read::<u8>()) };
+    log!("(pers) Read LP start encoding {lpad_start_encoding:?}");
+
+    let lpad_base = unsafe {
+        // base address for landing pad offsets
+        if lpad_start_encoding != gimli::DW_EH_PE_omit {
+            read_encoded_pointer(&mut reader, context, lpad_start_encoding)?
+        } else {
+            log!("(pers) (is omit)");
+            func_start
+        }
+    };
+    log!("(pers) read landingpad base: {lpad_base:?}");
+
+    let types_table_encoding = unsafe { DwEhPe(reader.read::<u8>()) };
+    log!("(pers) read ttype encoding: {types_table_encoding:?}");
+
+    // If no value for types_table_encoding was given it means that there's no
+    // types_table, therefore we can't possibly use this lpad.
+    if types_table_encoding == gimli::DW_EH_PE_omit {
+        log!("(pers) ttype is omit, returning None");
+        return Ok(EHAction::None);
+    }
+
+    let types_table_base_offset = unsafe { reader.read_uleb128() };
+
+    let types_table_base = unsafe {
+        log!("(pers) read class_info offset {types_table_base_offset:?}");
+        reader.ptr.wrapping_add(types_table_base_offset as _)
+    };
+    log!("(pers) read types_table_base sits at offset {types_table_base:?}");
+
+    let call_site_table_encoding = unsafe { DwEhPe(reader.read::<u8>()) };
+    log!("(pers) read call_site_table_encoding is {call_site_table_encoding:?}");
+
+    let call_site_table_size = unsafe { reader.read_uleb128() };
+    let action_table = unsafe {
+        log!("(pers) read call_site has length {call_site_table_size:?}");
+        reader.ptr.wrapping_add(call_site_table_size 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 {
+            let call_site_record_reader = &mut reader;
+            unsafe {
+                // Offset of the call site relative to the previous call site, counted in number of 16-byte bundles
+                let call_site_start =
+                    read_encoded_offset(call_site_record_reader, call_site_table_encoding)?;
+                let call_site_length =
+                    read_encoded_offset(call_site_record_reader, call_site_table_encoding)?;
+                // Offset of the landing pad, typically a byte offset relative to the LPStart address.
+                let call_site_lpad =
+                    read_encoded_offset(call_site_record_reader, call_site_table_encoding)?;
+                // Offset of the first associated action record, relative to the start of the actions table.
+                // This value is biased by 1 (1 indicates the start of the actions table), and 0 indicates that there are no actions.
+                let call_site_action_entry = call_site_record_reader.read_uleb128();
+
+                log!("(pers) read cs_start is {call_site_start:?}");
+                log!("(pers) read cs_len is {call_site_length:?}");
+                log!("(pers) read cs_lpad is {call_site_lpad:?}");
+                log!("(pers) read cs_ae is {call_site_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(call_site_start) {
+                    break;
+                }
+
+                // Call site matches the current ip. It's a candidate.
+                if ip < func_start.wrapping_add(call_site_start + call_site_length) {
+                    log!(
+                        "(pers) found a matching call site: {func_start:?} <= {ip:?} <= {:?}",
+                        func_start.wrapping_add(call_site_start + call_site_length)
+                    );
+                    if call_site_lpad == 0 {
+                        return Ok(EHAction::None);
+                    } else {
+                        let lpad = lpad_base.wrapping_add(call_site_lpad);
+                        let mut catches = vec![];
+
+                        log!("(pers) lpad sits at {lpad:?}");
+
+                        if call_site_action_entry == 0 {
+                            // We don't generate cleanup clauses, so this can't happen
+                            return Ok(EHAction::Terminate);
+                        }
+
+                        log!("(pers) read cs_action_entry: {call_site_action_entry}");
+                        log!("(pers) action_table: {action_table:?}");
+
+                        // Convert 1-based byte offset into
+                        let mut action_record: *const u8 =
+                            action_table.wrapping_add((call_site_action_entry - 1) as usize);
+
+                        log!("(pers) first action at: {action_record:?}");
+
+                        loop {
+                            // Read the action record.
+                            let mut action_record_reader = DwarfReader::new(action_record);
+                            // The two record kinds have the same format, with only small differences.
+                            // They are distinguished by the "type_filter" field: Catch clauses have strictly positive switch values,
+                            // and exception specifications have strictly negative switch values. Value 0 indicates a catch-all clause.
+                            let type_filter = action_record_reader.read_sleb128();
+                            log!(
+                                "(pers) type_filter for action #{call_site_action_entry}: {type_filter:?}"
+                            );
+
+                            if type_filter > 0 {
+                                // This is a catch clause so the type_filter is an index into the types table.
+                                //
+                                // Positive value, starting at 1.
+                                // Index in the types table of the __typeinfo for the catch-clause type.
+                                // 1 is the first word preceding TTBase, 2 is the second word, and so on.
+                                // Used by the runtime to check if the thrown exception type matches the catch-clause type.
+                                let types_table_index = type_filter;
+                                if types_table_base.is_null() {
+                                    panic!();
+                                }
+
+                                let tag_ptr = {
+                                    let new_types_table_index =
+                                        match DwEhPe(types_table_encoding.0 & 0x0f) {
+                                            gimli::DW_EH_PE_absptr => {
+                                                type_filter * (size_of::<*const u8>() as i64)
+                                            }
+                                            gimli::DW_EH_PE_sdata2 | gimli::DW_EH_PE_udata2 => {
+                                                type_filter * 2
+                                            }
+                                            gimli::DW_EH_PE_sdata4 | gimli::DW_EH_PE_udata4 => {
+                                                type_filter * 4
+                                            }
+                                            gimli::DW_EH_PE_sdata8 | gimli::DW_EH_PE_udata8 => {
+                                                type_filter * 8
+                                            }
+                                            _ => panic!(),
+                                        };
+
+                                    log!(
+                                        "(pers) new_types_table_index for action #{call_site_action_entry}: {new_types_table_index:?}"
+                                    );
+
+                                    let typeinfo = types_table_base
+                                        .wrapping_sub(new_types_table_index as usize);
+                                    log!("(pers) reading ttype info from {typeinfo:?}");
+                                    read_encoded_pointer(
+                                        // Basically just reader.read() a SLEB128.
+                                        &mut DwarfReader::new(typeinfo),
+                                        context,
+                                        types_table_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 type_filter == 0 {
+                                // We don't create cleanup clauses, so this can't happen
+                                return Ok(EHAction::Terminate);
+                            }
+
+                            let next_action_record = action_record_reader.clone().read_sleb128();
+                            if next_action_record == 0 {
+                                return Ok(if catches.is_empty() {
+                                    EHAction::None
+                                } else {
+                                    EHAction::CatchSpecific {
+                                        lpad,
+                                        tags: catches,
+                                    }
+                                });
+                            }
+
+                            action_record = action_record_reader
+                                .ptr
+                                .wrapping_add(next_action_record as usize);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Ip is not present in the table. This indicates a nounwind call.
+        Ok(EHAction::Terminate)
+    } else {
+        todo!()
+    }
+}
+
+#[inline]
+fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
+    if align.is_power_of_two() {
+        Ok(unrounded.next_multiple_of(align))
+    } 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: DwEhPe) -> Result<usize, ()> {
+    if encoding == gimli::DW_EH_PE_omit || encoding.0 & 0xF0 != 0 {
+        return Err(());
+    }
+    let result = unsafe {
+        match DwEhPe(encoding.0 & 0x0F) {
+            // despite the name, LLVM also uses absptr for offsets instead of pointers
+            gimli::DW_EH_PE_absptr => reader.read::<usize>(),
+            gimli::DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
+            gimli::DW_EH_PE_udata2 => reader.read::<u16>() as usize,
+            gimli::DW_EH_PE_udata4 => reader.read::<u32>() as usize,
+            gimli::DW_EH_PE_udata8 => reader.read::<u64>() as usize,
+            gimli::DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
+            gimli::DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
+            gimli::DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
+            gimli::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: DwEhPe,
+) -> Result<*const u8, ()> {
+    if encoding == gimli::DW_EH_PE_omit {
+        return Err(());
+    }
+
+    log!("(pers) About to read encoded pointer at {:?}", reader.ptr);
+
+    let base_ptr = match DwEhPe(encoding.0 & 0x70) {
+        gimli::DW_EH_PE_absptr => {
+            log!("(pers) encoding is: DW_EH_PE_absptr");
+            core::ptr::null()
+        }
+        // relative to address of the encoded value, despite the name
+        gimli::DW_EH_PE_pcrel => {
+            log!("(pers) encoding is: DW_EH_PE_pcrel");
+            reader.ptr
+        }
+        gimli::DW_EH_PE_funcrel => {
+            log!("(pers) encoding is: DW_EH_PE_funcrel");
+            if context.func_start.is_null() {
+                return Err(());
+            }
+            context.func_start
+        }
+        gimli::DW_EH_PE_textrel => {
+            log!("(pers) encoding is: DW_EH_PE_textrel");
+            (*context.get_text_start)()
+        }
+        gimli::DW_EH_PE_datarel => {
+            log!("(pers) encoding is: DW_EH_PE_datarel");
+
+            (*context.get_data_start)()
+        }
+        // aligned means the value is aligned to the size of a pointer
+        gimli::DW_EH_PE_aligned => {
+            log!("(pers) encoding is: 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 DwEhPe(encoding.0 & 0x0f) != gimli::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, DwEhPe(encoding.0 & 0x0f))? };
+        log!("(pers) read offset is {offset:x?}");
+        base_ptr.wrapping_add(offset)
+    };
+
+    log!("(pers) about to read from {ptr:?}");
+
+    if encoding.0 & gimli::DW_EH_PE_indirect.0 != 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..88cb4dfafd
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/gcc.rs
@@ -0,0 +1,324 @@
+//! 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 std::ffi::c_void;
+
+use libunwind::{self as uw};
+use wasmer_types::TagIndex;
+
+use crate::{InternalStoreHandle, StoreHandle, StoreObjects, VMContext, VMExceptionRef};
+
+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 exnref: u32,
+
+    // First stage -> second stage communication
+    pub current_frame_info: Option<Box<CurrentFrameInfo>>,
+}
+
+#[repr(C)]
+pub struct CurrentFrameInfo {
+    pub catch_tags: Vec<u32>,
+    pub has_catch_all: bool,
+}
+
+impl UwExceptionWrapper {
+    pub fn new(exnref: u32) -> Self {
+        Self {
+            _uwe: uw::_Unwind_Exception {
+                exception_class: WASMER_EXCEPTION_CLASS,
+                exception_cleanup: Some(deallocate_exception),
+                private_1: core::ptr::null::<u8>() as usize as _,
+                private_2: 0,
+            },
+            canary: &CANARY,
+            exnref,
+            current_frame_info: None,
+        }
+    }
+}
+
+#[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
+
+#[cfg(target_arch = "powerpc64")]
+const UNWIND_DATA_REG: (i32, i32) = (3, 4); // R3, R4
+
+macro_rules! log {
+    ($e: expr) => {
+        if false {
+            eprintln!($e)
+        }
+
+    };
+
+    ($($e: expr),*) => {
+        if false {
+            eprintln!($($e),*)
+        }
+
+    };
+}
+
+#[unsafe(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 eh_action = match find_eh_action(context) {
+            Ok(action) => action,
+            Err(_) => {
+                return uw::_Unwind_Reason_Code__URC_FATAL_PHASE1_ERROR;
+            }
+        };
+
+        let is_catch_specific_or_all = matches!(&eh_action, EHAction::CatchSpecificOrAll { .. });
+        log!("[wasmer][eh] stage1 action: {:?}", eh_action);
+
+        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
+            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 } => {
+                    log!(
+                        "[wasmer][eh] stage1 catch tags={:?} catch_all={}",
+                        tags,
+                        is_catch_specific_or_all
+                    );
+                    (*uw_exc).current_frame_info = Some(Box::new(CurrentFrameInfo {
+                        catch_tags: tags,
+                        has_catch_all: is_catch_specific_or_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,
+            }
+        }
+    }
+}
+
+#[unsafe(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");
+        };
+
+        log!(
+            "[wasmer][eh] stage2 catch_tags={:?} has_catch_all={}",
+            current_frame_info.catch_tags,
+            current_frame_info.has_catch_all
+        );
+
+        let instance = (*vmctx).instance();
+        let exn = super::exn_obj_from_exnref(vmctx, (*exception_object).exnref);
+
+        for tag in current_frame_info.catch_tags {
+            log!("[wasmer][eh] stage2 checking tag {}", tag);
+            let unique_tag = instance.shared_tag_ptr(TagIndex::from_u32(tag)).index();
+            if unique_tag == (*exn).tag_index() {
+                return tag as i32;
+            }
+        }
+
+        if current_frame_info.has_catch_all {
+            log!("[wasmer][eh] stage2 falling back to catch-all");
+            CATCH_ALL_TAG_VALUE
+        } else {
+            log!("[wasmer][eh] stage2 found no match");
+            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 read_exnref(exception: *mut c_void) -> u32 {
+    if exception.is_null() {
+        0
+    } else {
+        unsafe { (*(exception as *mut UwExceptionWrapper)).exnref }
+    }
+}
+
+/// # Safety
+///
+/// Performs libunwind unwinding magic. Highly unsafe.
+pub unsafe fn throw(ctx: &StoreObjects, exnref: u32) -> ! {
+    unsafe {
+        log!("[wasmer][eh] throw resolved exnref={exnref}");
+        if exnref == 0 {
+            crate::raise_lib_trap(crate::Trap::lib(
+                wasmer_types::TrapCode::UninitializedExnRef,
+            ))
+        }
+
+        let exception = Box::new(UwExceptionWrapper::new(exnref));
+        let exception_ptr = Box::into_raw(exception);
+
+        // WARNING: The return code from _Unwind_RaiseException is unreliable on some targets
+        // due to GCC compiler issues (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114843).
+        // We proceed regardless of the actual return value (similarly to the libstdc++).
+        uw::_Unwind_RaiseException(exception_ptr as *mut libunwind::_Unwind_Exception);
+        delete_exception(exception_ptr as *mut c_void);
+
+        let exnref = VMExceptionRef(StoreHandle::from_internal(
+            ctx.id(),
+            InternalStoreHandle::from_index(exnref as usize).unwrap(),
+        ));
+        log!(
+            "[wasmer][eh] throw -> _Unwind_RaiseException returned (personality={:p})",
+            wasmer_eh_personality as *const ()
+        );
+        crate::raise_lib_trap(crate::Trap::uncaught_exception(exnref, ctx))
+    }
+}
+
+pub unsafe fn delete_exception(exception: *mut c_void) {
+    unsafe {
+        if !exception.is_null() {
+            uw::_Unwind_DeleteException(exception as *mut uw::_Unwind_Exception);
+        }
+    }
+}
+
+unsafe extern "C" fn deallocate_exception(
+    _: uw::_Unwind_Reason_Code,
+    exception: *mut uw::_Unwind_Exception,
+) {
+    unsafe {
+        let exception = Box::from_raw(exception as *mut UwExceptionWrapper);
+        drop(exception);
+    }
+}
diff --git a/lib/vm/src/libcalls/eh/mod.rs b/lib/vm/src/libcalls/eh/mod.rs
new file mode 100644
index 0000000000..9c96a599da
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/mod.rs
@@ -0,0 +1,71 @@
+// Part of the logic, here, is borrowed as-is from rust's stdlib.
+
+use crate::{InternalStoreHandle, VMContext, VMExceptionObj};
+
+mod dwarf;
+
+cfg_if::cfg_if! {
+    if #[cfg(any(target_env = "msvc", target_family = "wasm"))] {
+        /// The implementation of Wasmer's personality function.
+        ///
+        /// # Safety
+        ///
+        /// Performs libunwind unwinding magic.
+        pub unsafe fn wasmer_eh_personality() {
+            panic!()
+        }
+
+        /// 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 fn wasmer_eh_personality2() {
+            panic!()
+        }
+
+        pub unsafe fn read_exnref(_exception: *mut std::ffi::c_void) -> u32 {
+            panic!()
+        }
+
+        /// # Safety
+        ///
+        /// Performs libunwind unwinding magic. Highly unsafe.
+        pub unsafe fn throw(_ctx: &crate::StoreObjects, _exnref: u32) -> ! {
+            panic!()
+        }
+
+        /// Given a pointer to a caught exception, return the exnref contained within.
+        ///
+        /// # Safety
+        ///
+        /// `exception` must be a pointer the platform-specific exception type; this is
+        /// `UwExceptionWrapper` for gcc.
+        pub unsafe fn delete_exception(_exception: *mut std::ffi::c_void) {
+            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
+    }
+}
+
+pub(crate) fn exn_obj_from_exnref(vmctx: *mut VMContext, exnref: u32) -> *mut VMExceptionObj {
+    let instance = unsafe { (*vmctx).instance_mut() };
+    let exnref = InternalStoreHandle::<VMExceptionObj>::from_index(exnref as usize).unwrap();
+    let exn = exnref.get_mut(instance.context_mut());
+    exn as *mut VMExceptionObj
+}
diff --git a/lib/vm/src/memory.rs b/lib/vm/src/memory.rs
index 1052b61ef0..a77917b174 100644
--- a/lib/vm/src/memory.rs
+++ b/lib/vm/src/memory.rs
@@ -5,11 +5,15 @@
 //!
 //! `Memory` is to WebAssembly linear memories what `Table` is to WebAssembly tables.
 
-use crate::mmap::MmapType;
 use crate::threadconditions::ThreadConditions;
 pub use crate::threadconditions::{NotifyLocation, WaiterError};
 use crate::trap::Trap;
-use crate::{mmap::Mmap, store::MaybeInstanceOwned, vmcontext::VMMemoryDefinition};
+use crate::{
+    mmap::{Mmap, MmapType},
+    store::MaybeInstanceOwned,
+    threadconditions::ExpectedValue,
+    vmcontext::VMMemoryDefinition,
+};
 use more_asserts::assert_ge;
 use std::cell::UnsafeCell;
 use std::convert::TryInto;
@@ -59,19 +63,19 @@ impl WasmMmap {
             })?;
         let prev_pages = self.size;
 
-        if let Some(maximum) = conf.maximum {
-            if new_pages > maximum {
-                return Err(MemoryError::CouldNotGrow {
-                    current: self.size,
-                    attempted_delta: delta,
-                });
-            }
+        if let Some(maximum) = conf.maximum
+            && new_pages > maximum
+        {
+            return Err(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            });
         }
 
         // 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,
@@ -139,6 +143,12 @@ impl WasmMmap {
     /// Resets the memory down to a zero size
     fn reset(&mut self) -> Result<(), MemoryError> {
         self.size.0 = 0;
+        // update memory definition
+        unsafe {
+            let mut md_ptr = self.vm_memory_definition.as_ptr();
+            let md = md_ptr.as_mut();
+            md.current_length = 0;
+        }
         Ok(())
     }
 
@@ -239,13 +249,15 @@ impl VMOwnedMemory {
         style: &MemoryStyle,
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
-        Self::new_internal(
-            memory,
-            style,
-            Some(vm_memory_location),
-            None,
-            MmapType::Private,
-        )
+        unsafe {
+            Self::new_internal(
+                memory,
+                style,
+                Some(vm_memory_location),
+                None,
+                MmapType::Private,
+            )
+        }
     }
 
     /// Create a new linear memory instance with specified minimum and maximum number of wasm pages
@@ -264,13 +276,15 @@ impl VMOwnedMemory {
         backing_file: Option<std::path::PathBuf>,
         memory_type: MmapType,
     ) -> Result<Self, MemoryError> {
-        Self::new_internal(
-            memory,
-            style,
-            Some(vm_memory_location),
-            backing_file,
-            memory_type,
-        )
+        unsafe {
+            Self::new_internal(
+                memory,
+                style,
+                Some(vm_memory_location),
+                backing_file,
+                memory_type,
+            )
+        }
     }
 
     /// Build a `Memory` with either self-owned or VM owned metadata.
@@ -281,82 +295,84 @@ impl VMOwnedMemory {
         backing_file: Option<std::path::PathBuf>,
         memory_type: MmapType,
     ) -> Result<Self, MemoryError> {
-        if memory.minimum > Pages::max_value() {
-            return Err(MemoryError::MinimumMemoryTooLarge {
-                min_requested: memory.minimum,
-                max_allowed: Pages::max_value(),
-            });
-        }
-        // `maximum` cannot be set to more than `65536` pages.
-        if let Some(max) = memory.maximum {
-            if max > Pages::max_value() {
-                return Err(MemoryError::MaximumMemoryTooLarge {
-                    max_requested: max,
+        unsafe {
+            if memory.minimum > Pages::max_value() {
+                return Err(MemoryError::MinimumMemoryTooLarge {
+                    min_requested: memory.minimum,
                     max_allowed: Pages::max_value(),
                 });
             }
-            if max < memory.minimum {
-                return Err(MemoryError::InvalidMemory {
-                    reason: format!(
-                        "the maximum ({} pages) is less than the minimum ({} pages)",
-                        max.0, memory.minimum.0
-                    ),
-                });
-            }
-        }
-
-        let offset_guard_bytes = style.offset_guard_size() as usize;
-
-        let minimum_pages = match style {
-            MemoryStyle::Dynamic { .. } => memory.minimum,
-            MemoryStyle::Static { bound, .. } => {
-                assert_ge!(*bound, memory.minimum);
-                *bound
+            // `maximum` cannot be set to more than `65536` pages.
+            if let Some(max) = memory.maximum {
+                if max > Pages::max_value() {
+                    return Err(MemoryError::MaximumMemoryTooLarge {
+                        max_requested: max,
+                        max_allowed: Pages::max_value(),
+                    });
+                }
+                if max < memory.minimum {
+                    return Err(MemoryError::InvalidMemory {
+                        reason: format!(
+                            "the maximum ({} pages) is less than the minimum ({} pages)",
+                            max.0, memory.minimum.0
+                        ),
+                    });
+                }
             }
-        };
-        let minimum_bytes = minimum_pages.bytes().0;
-        let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap();
-        let mapped_pages = memory.minimum;
-        let mapped_bytes = mapped_pages.bytes();
 
-        let mut alloc =
-            Mmap::accessible_reserved(mapped_bytes.0, request_bytes, backing_file, memory_type)
-                .map_err(MemoryError::Region)?;
+            let offset_guard_bytes = style.offset_guard_size() as usize;
 
-        let base_ptr = alloc.as_mut_ptr();
-        let mem_length = memory
-            .minimum
-            .bytes()
-            .0
-            .max(alloc.as_slice_accessible().len());
-        let mmap = WasmMmap {
-            vm_memory_definition: if let Some(mem_loc) = vm_memory_location {
-                {
-                    let mut ptr = mem_loc;
-                    let md = ptr.as_mut();
-                    md.base = base_ptr;
-                    md.current_length = mem_length;
+            let minimum_pages = match style {
+                MemoryStyle::Dynamic { .. } => memory.minimum,
+                MemoryStyle::Static { bound, .. } => {
+                    assert_ge!(*bound, memory.minimum);
+                    *bound
                 }
-                MaybeInstanceOwned::Instance(mem_loc)
-            } else {
-                MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMMemoryDefinition {
-                    base: base_ptr,
-                    current_length: mem_length,
-                })))
-            },
-            alloc,
-            size: Bytes::from(mem_length).try_into().unwrap(),
-        };
+            };
+            let minimum_bytes = minimum_pages.bytes().0;
+            let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap();
+            let mapped_pages = memory.minimum;
+            let mapped_bytes = mapped_pages.bytes();
+
+            let mut alloc =
+                Mmap::accessible_reserved(mapped_bytes.0, request_bytes, backing_file, memory_type)
+                    .map_err(MemoryError::Region)?;
 
-        Ok(Self {
-            mmap,
-            config: VMMemoryConfig {
-                maximum: memory.maximum,
-                offset_guard_size: offset_guard_bytes,
-                memory: *memory,
-                style: *style,
-            },
-        })
+            let base_ptr = alloc.as_mut_ptr();
+            let mem_length = memory
+                .minimum
+                .bytes()
+                .0
+                .max(alloc.as_slice_accessible().len());
+            let mmap = WasmMmap {
+                vm_memory_definition: if let Some(mem_loc) = vm_memory_location {
+                    {
+                        let mut ptr = mem_loc;
+                        let md = ptr.as_mut();
+                        md.base = base_ptr;
+                        md.current_length = mem_length;
+                    }
+                    MaybeInstanceOwned::Instance(mem_loc)
+                } else {
+                    MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMMemoryDefinition {
+                        base: base_ptr,
+                        current_length: mem_length,
+                    })))
+                },
+                alloc,
+                size: Bytes::from(mem_length).try_into().unwrap(),
+            };
+
+            Ok(Self {
+                mmap,
+                config: VMMemoryConfig {
+                    maximum: memory.maximum,
+                    offset_guard_size: offset_guard_bytes,
+                    memory: *memory,
+                    style: *style,
+                },
+            })
+        }
     }
 
     /// Converts this owned memory into shared memory
@@ -481,7 +497,9 @@ impl VMSharedMemory {
         style: &MemoryStyle,
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
-        Ok(VMOwnedMemory::from_definition(memory, style, vm_memory_location)?.to_shared())
+        unsafe {
+            Ok(VMOwnedMemory::from_definition(memory, style, vm_memory_location)?.to_shared())
+        }
     }
 
     /// Create a new linear memory instance with specified minimum and maximum number of wasm pages
@@ -500,14 +518,16 @@ impl VMSharedMemory {
         backing_file: Option<std::path::PathBuf>,
         memory_type: MmapType,
     ) -> Result<Self, MemoryError> {
-        Ok(VMOwnedMemory::from_definition_with_file(
-            memory,
-            style,
-            vm_memory_location,
-            backing_file,
-            memory_type,
-        )?
-        .to_shared())
+        unsafe {
+            Ok(VMOwnedMemory::from_definition_with_file(
+                memory,
+                style,
+                vm_memory_location,
+                backing_file,
+                memory_type,
+            )?
+            .to_shared())
+        }
     }
 
     /// Copies this memory to a new memory
@@ -583,16 +603,21 @@ impl LinearMemory for VMSharedMemory {
     }
 
     // Add current thread to waiter list
-    fn do_wait(
+    unsafe fn do_wait(
         &mut self,
-        dst: NotifyLocation,
+        dst: u32,
+        expected: ExpectedValue,
         timeout: Option<Duration>,
     ) -> Result<u32, WaiterError> {
-        self.conditions.do_wait(dst, timeout)
+        let dst = NotifyLocation {
+            address: dst,
+            memory_base: self.mmap.read().unwrap().alloc.as_ptr() as *mut _,
+        };
+        unsafe { self.conditions.do_wait(dst, expected, timeout) }
     }
 
     /// Notify waiters from the wait list. Return the number of waiters notified
-    fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+    fn do_notify(&mut self, dst: u32, count: u32) -> u32 {
         self.conditions.do_notify(dst, count)
     }
 
@@ -671,7 +696,7 @@ impl LinearMemory for VMMemory {
 
     /// Initialize memory with data
     unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
-        self.0.initialize_with_data(start, data)
+        unsafe { self.0.initialize_with_data(start, data) }
     }
 
     /// Copies this memory to a new memory
@@ -680,16 +705,17 @@ impl LinearMemory for VMMemory {
     }
 
     // Add current thread to waiter list
-    fn do_wait(
+    unsafe fn do_wait(
         &mut self,
-        dst: NotifyLocation,
+        dst: u32,
+        expected: ExpectedValue,
         timeout: Option<Duration>,
     ) -> Result<u32, WaiterError> {
-        self.0.do_wait(dst, timeout)
+        unsafe { self.0.do_wait(dst, expected, timeout) }
     }
 
     /// Notify waiters from the wait list. Return the number of waiters notified
-    fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+    fn do_notify(&mut self, dst: u32, count: u32) -> u32 {
         self.0.do_notify(dst, count)
     }
 
@@ -729,19 +755,21 @@ impl VMMemory {
         style: &MemoryStyle,
         vm_memory_location: NonNull<VMMemoryDefinition>,
     ) -> Result<Self, MemoryError> {
-        Ok(if memory.shared {
-            Self(Box::new(VMSharedMemory::from_definition(
-                memory,
-                style,
-                vm_memory_location,
-            )?))
-        } else {
-            Self(Box::new(VMOwnedMemory::from_definition(
-                memory,
-                style,
-                vm_memory_location,
-            )?))
-        })
+        unsafe {
+            Ok(if memory.shared {
+                Self(Box::new(VMSharedMemory::from_definition(
+                    memory,
+                    style,
+                    vm_memory_location,
+                )?))
+            } else {
+                Self(Box::new(VMOwnedMemory::from_definition(
+                    memory,
+                    style,
+                    vm_memory_location,
+                )?))
+            })
+        }
     }
 
     /// Creates VMMemory from a custom implementation - the following into implementations
@@ -768,12 +796,14 @@ pub unsafe fn initialize_memory_with_data(
     start: usize,
     data: &[u8],
 ) -> Result<(), Trap> {
-    let mem_slice = slice::from_raw_parts_mut(memory.base, memory.current_length);
-    let end = start + data.len();
-    let to_init = &mut mem_slice[start..end];
-    to_init.copy_from_slice(data);
+    unsafe {
+        let mem_slice = slice::from_raw_parts_mut(memory.base, memory.current_length);
+        let end = start + data.len();
+        let to_init = &mut mem_slice[start..end];
+        to_init.copy_from_slice(data);
 
-    Ok(())
+        Ok(())
+    }
 }
 
 /// Represents memory that is used by the WebAsssembly module
@@ -822,26 +852,35 @@ where
     /// This function is unsafe because WebAssembly specification requires that data is always set at initialization time.
     /// It should be the implementors responsibility to make sure this respects the spec
     unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
-        let memory = self.vmmemory().as_ref();
+        unsafe {
+            let memory = self.vmmemory().as_ref();
 
-        initialize_memory_with_data(memory, start, data)
+            initialize_memory_with_data(memory, start, data)
+        }
     }
 
     /// Copies this memory to a new memory
     fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError>;
 
-    /// Add current thread to the waiter hash, and wait until notified or timout.
-    /// Return 0 if the waiter has been notified, 2 if the timeout occured, or None if en error happened
-    fn do_wait(
+    /// Add current thread to the waiter hash, and wait until notified or timeout.
+    /// Return 0 if the waiter has been notified, 1 if there was a value mismatch,
+    /// or 2 if the timeout occurred.
+    ///
+    /// # Safety
+    /// the destination address must be a valid offset within this memory. It must also
+    /// be properly aligned for the expected value type; either 4-byte aligned for
+    /// `ExpectedValue::U32` or 8-byte aligned for `ExpectedValue::u64`.
+    unsafe fn do_wait(
         &mut self,
-        _dst: NotifyLocation,
+        _dst: u32,
+        _expected: ExpectedValue,
         _timeout: Option<Duration>,
     ) -> Result<u32, WaiterError> {
         Err(WaiterError::Unimplemented)
     }
 
     /// Notify waiters from the wait list. Return the number of waiters notified
-    fn do_notify(&mut self, _dst: NotifyLocation, _count: u32) -> u32 {
+    fn do_notify(&mut self, _dst: u32, _count: u32) -> u32 {
         0
     }
 
diff --git a/lib/vm/src/mmap.rs b/lib/vm/src/mmap.rs
index e08f49dc1e..75a18524f9 100644
--- a/lib/vm/src/mmap.rs
+++ b/lib/vm/src/mmap.rs
@@ -9,11 +9,6 @@ use std::io;
 use std::ptr;
 use std::slice;
 
-/// Round `size` up to the nearest multiple of `page_size`.
-fn round_up_to_page_size(size: usize, page_size: usize) -> usize {
-    (size + (page_size - 1)) & !(page_size - 1)
-}
-
 /// A simple struct consisting of a page-aligned pointer to page-aligned
 /// and initially-zeroed memory and a length.
 #[derive(Debug)]
@@ -25,6 +20,7 @@ pub struct Mmap {
     ptr: usize,
     total_size: usize,
     accessible_size: usize,
+    #[cfg_attr(target_os = "windows", allow(dead_code))]
     sync_on_drop: bool,
 }
 
@@ -56,7 +52,7 @@ impl Mmap {
     /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory.
     pub fn with_at_least(size: usize) -> Result<Self, String> {
         let page_size = region::page::size();
-        let rounded_size = round_up_to_page_size(size, page_size);
+        let rounded_size = size.next_multiple_of(page_size);
         Self::accessible_reserved(rounded_size, rounded_size, None, MmapType::Private)
     }
 
@@ -98,7 +94,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())?;
@@ -193,7 +189,7 @@ impl Mmap {
         _memory_type: MmapType,
     ) -> Result<Self, String> {
         use windows_sys::Win32::System::Memory::{
-            VirtualAlloc, MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE,
+            MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE, VirtualAlloc,
         };
 
         let page_size = region::page::size();
@@ -274,7 +270,7 @@ impl Mmap {
     #[cfg(target_os = "windows")]
     pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> {
         use std::ffi::c_void;
-        use windows_sys::Win32::System::Memory::{VirtualAlloc, MEM_COMMIT, PAGE_READWRITE};
+        use windows_sys::Win32::System::Memory::{MEM_COMMIT, PAGE_READWRITE, VirtualAlloc};
         let page_size = region::page::size();
         assert_eq!(start & (page_size - 1), 0);
         assert_eq!(len & (page_size - 1), 0);
@@ -395,9 +391,9 @@ impl Drop for Mmap {
 
     #[cfg(target_os = "windows")]
     fn drop(&mut self) {
-        if self.len() != 0 {
+        if !self.is_empty() {
             use std::ffi::c_void;
-            use windows_sys::Win32::System::Memory::{VirtualFree, MEM_RELEASE};
+            use windows_sys::Win32::System::Memory::{MEM_RELEASE, VirtualFree};
             let r = unsafe { VirtualFree(self.ptr as *mut c_void, 0, MEM_RELEASE) };
             assert_ne!(r, 0);
         }
@@ -408,16 +404,3 @@ fn _assert() {
     fn _assert_send_sync<T: Send + Sync>() {}
     _assert_send_sync::<Mmap>();
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_round_up_to_page_size() {
-        assert_eq!(round_up_to_page_size(0, 4096), 0);
-        assert_eq!(round_up_to_page_size(1, 4096), 4096);
-        assert_eq!(round_up_to_page_size(4096, 4096), 4096);
-        assert_eq!(round_up_to_page_size(4097, 4096), 8192);
-    }
-}
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 87%
rename from lib/vm/src/probestack.rs
rename to lib/vm/src/probestack/mod.rs
index 814ddf9c20..5c1e978c40 100644
--- a/lib/vm/src/probestack.rs
+++ b/lib/vm/src/probestack/mod.rs
@@ -14,6 +14,10 @@
 //!
 //! [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
+mod compiler_builtins;
+
 // A declaration for the stack probe function in Rust's standard library, for
 // catching callstack overflow.
 cfg_if::cfg_if! {
@@ -22,7 +26,7 @@ cfg_if::cfg_if! {
             target_env = "msvc",
             target_pointer_width = "64"
             ))] {
-        extern "C" {
+        unsafe extern "C" {
             pub fn __chkstk();
         }
         /// The probestack for 64bit Windows when compiled with MSVC (note the double underscore)
@@ -32,13 +36,13 @@ cfg_if::cfg_if! {
             target_env = "msvc",
             target_pointer_width = "32"
             ))] {
-        extern "C" {
+        unsafe extern "C" {
             pub fn _chkstk();
         }
         /// The probestack for 32bit Windows when compiled with MSVC (note the singular underscore)
         pub const PROBESTACK: unsafe extern "C" fn() = _chkstk;
     } else if #[cfg(all(target_os = "windows", target_env = "gnu"))] {
-        extern "C" {
+        unsafe extern "C" {
             // ___chkstk (note the triple underscore) is implemented in compiler-builtins/src/x86_64.rs
             // by the Rust compiler for the MinGW target
             #[cfg(all(target_os = "windows", target_env = "gnu"))]
@@ -55,10 +59,7 @@ 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();
-        }
         /// The probestack based on the Rust probestack
-        pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack;
+        pub static PROBESTACK: unsafe extern "C" fn() = compiler_builtins::__rust_probestack;
     }
 }
diff --git a/lib/vm/src/sig_registry.rs b/lib/vm/src/sig_registry.rs
index 1ae661a7ed..a27b085a99 100644
--- a/lib/vm/src/sig_registry.rs
+++ b/lib/vm/src/sig_registry.rs
@@ -5,8 +5,8 @@
 //! signature checking.
 
 use crate::vmcontext::VMSharedSignatureIndex;
-use more_asserts::{assert_lt, debug_assert_lt};
-use std::collections::{hash_map, HashMap};
+use more_asserts::debug_assert_lt;
+use std::collections::{HashMap, hash_map};
 use std::convert::TryFrom;
 use std::sync::RwLock;
 use wasmer_types::FunctionType;
@@ -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..0611e74912 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,9 +9,13 @@ 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 {
     ($($field:ident => $ty:ty,)*) => {
         $(
@@ -25,6 +30,7 @@ macro_rules! impl_context_object {
         )*
     };
 }
+
 impl_context_object! {
     functions => VMFunction,
     tables => VMTable,
@@ -32,6 +38,8 @@ impl_context_object! {
     instances => VMInstance,
     memories => VMMemory,
     extern_objs => VMExternObj,
+    exceptions => VMExceptionObj,
+    tags => VMTag,
     function_environments => VMFunctionEnvironment,
 }
 
@@ -45,10 +53,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
@@ -79,7 +117,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> Iter<VMGlobal> {
+    pub fn iter_globals(&self) -> Iter<'_, VMGlobal> {
         self.globals.iter()
     }
 
@@ -105,6 +143,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 +238,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..47f49f0002 100644
--- a/lib/vm/src/table.rs
+++ b/lib/vm/src/table.rs
@@ -5,12 +5,11 @@
 //!
 //! `Table` is to WebAssembly tables what `Memory` is to WebAssembly linear memories.
 
-use crate::store::MaybeInstanceOwned;
-use crate::vmcontext::VMTableDefinition;
 use crate::Trap;
 use crate::VMExternRef;
 use crate::VMFuncRef;
-use derivative::Derivative;
+use crate::store::MaybeInstanceOwned;
+use crate::vmcontext::VMTableDefinition;
 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>,
 }
 
@@ -110,7 +106,7 @@ impl VMTable {
         style: &TableStyle,
         vm_table_location: NonNull<VMTableDefinition>,
     ) -> Result<Self, String> {
-        Self::new_inner(table, style, Some(vm_table_location))
+        unsafe { Self::new_inner(table, style, Some(vm_table_location)) }
     }
 
     /// Create a new `Table` with either self-owned or VM owned metadata.
@@ -119,48 +115,49 @@ impl VMTable {
         style: &TableStyle,
         vm_table_location: Option<NonNull<VMTableDefinition>>,
     ) -> Result<Self, String> {
-        match table.ty {
-            ValType::FuncRef | ValType::ExternRef => (),
-            ty => {
-                return Err(format!(
-                    "tables of types other than funcref or externref ({})",
-                    ty
-                ))
-            }
-        };
-        if let Some(max) = table.maximum {
-            if max < table.minimum {
+        unsafe {
+            match table.ty {
+                ValType::FuncRef | ValType::ExternRef => (),
+                ty => {
+                    return Err(format!(
+                        "tables of types other than funcref or externref ({ty})",
+                    ));
+                }
+            };
+            if let Some(max) = table.maximum
+                && max < table.minimum
+            {
                 return Err(format!(
                     "Table minimum ({}) is larger than maximum ({})!",
                     table.minimum, max
                 ));
             }
-        }
-        let table_minimum = usize::try_from(table.minimum)
-            .map_err(|_| "Table minimum is bigger than usize".to_string())?;
-        let mut vec = vec![RawTableElement::default(); table_minimum];
-        let base = vec.as_mut_ptr();
-        match style {
-            TableStyle::CallerChecksSignature => Ok(Self {
-                vec,
-                maximum: table.maximum,
-                table: *table,
-                style: style.clone(),
-                vm_table_definition: if let Some(table_loc) = vm_table_location {
-                    {
-                        let mut ptr = table_loc;
-                        let td = ptr.as_mut();
-                        td.base = base as _;
-                        td.current_elements = table_minimum as _;
-                    }
-                    MaybeInstanceOwned::Instance(table_loc)
-                } else {
-                    MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMTableDefinition {
-                        base: base as _,
-                        current_elements: table_minimum as _,
-                    })))
-                },
-            }),
+            let table_minimum = usize::try_from(table.minimum)
+                .map_err(|_| "Table minimum is bigger than usize".to_string())?;
+            let mut vec = vec![RawTableElement::default(); table_minimum];
+            let base = vec.as_mut_ptr();
+            match style {
+                TableStyle::CallerChecksSignature => Ok(Self {
+                    vec,
+                    maximum: table.maximum,
+                    table: *table,
+                    style: style.clone(),
+                    vm_table_definition: if let Some(table_loc) = vm_table_location {
+                        {
+                            let mut ptr = table_loc;
+                            let td = ptr.as_mut();
+                            td.base = base as _;
+                            td.current_elements = table_minimum as _;
+                        }
+                        MaybeInstanceOwned::Instance(table_loc)
+                    } else {
+                        MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMTableDefinition {
+                            base: base as _,
+                            current_elements: table_minimum as _,
+                        })))
+                    },
+                }),
+            }
         }
     }
 
@@ -196,7 +193,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 +244,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:?}")
                     }
                 };
 
@@ -282,12 +276,12 @@ impl VMTable {
 
         if src_index
             .checked_add(len)
-            .map_or(true, |n| n > src_table.size())
+            .is_none_or(|n| n > src_table.size())
         {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
 
-        if dst_index.checked_add(len).map_or(true, |m| m > self.size()) {
+        if dst_index.checked_add(len).is_none_or(|m| m > self.size()) {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
 
@@ -315,7 +309,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)
     }
 
@@ -328,11 +322,11 @@ impl VMTable {
     pub fn copy_within(&mut self, dst_index: u32, src_index: u32, len: u32) -> Result<(), Trap> {
         // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-copy
 
-        if src_index.checked_add(len).map_or(true, |n| n > self.size()) {
+        if src_index.checked_add(len).is_none_or(|n| n > self.size()) {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
 
-        if dst_index.checked_add(len).map_or(true, |m| m > self.size()) {
+        if dst_index.checked_add(len).is_none_or(|m| m > self.size()) {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
 
diff --git a/lib/vm/src/threadconditions.rs b/lib/vm/src/threadconditions.rs
index cdf6938ec5..a8cc2a5b81 100644
--- a/lib/vm/src/threadconditions.rs
+++ b/lib/vm/src/threadconditions.rs
@@ -1,9 +1,15 @@
+use std::{
+    sync::atomic::AtomicPtr,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+
 use dashmap::DashMap;
 use fnv::FnvBuildHasher;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use std::thread::{current, park, park_timeout, Thread};
-use std::time::Duration;
+use parking_lot::{Condvar, Mutex};
 use thiserror::Error;
 
 /// Error that can occur during wait/notify calls.
@@ -25,24 +31,39 @@ impl std::fmt::Display for WaiterError {
     }
 }
 
+/// Expected value for atomic waits
+pub enum ExpectedValue {
+    /// No expected value; this is used for native waits only.
+    None,
+
+    /// 32-bit expected value
+    U32(u32),
+
+    /// 64-bit expected value
+    U64(u64),
+}
+
 /// A location in memory for a Waiter
-#[derive(Hash, Eq, PartialEq, Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug)]
 pub struct NotifyLocation {
     /// The address of the Waiter location
     pub address: u32,
-}
-
-#[derive(Debug)]
-struct NotifyWaiter {
-    thread: Thread,
-    notified: bool,
+    /// The base of the memory this address is relative to
+    pub memory_base: *mut u8,
 }
 
 #[derive(Debug, Default)]
 struct NotifyMap {
     /// If set to true, all waits will fail with an error.
     closed: AtomicBool,
-    map: DashMap<NotifyLocation, Vec<NotifyWaiter>, FnvBuildHasher>,
+
+    // For each wait address, we store a mutex and a condvar. The condvar is
+    // used to handle sleeping and waking, while the mutex stores the
+    // (manually-updated) number of waiters on that address. This lets us
+    // know when there are no more waiters so we can clean up the map entry.
+    // note that using a Weak here would be insufficient since it can't
+    // clean up the map entries for us, only the mutexes/condvars.
+    map: DashMap<u32, Arc<(Mutex<u32>, Condvar)>, FnvBuildHasher>,
 }
 
 /// HashMap of Waiters for the Thread/Notify opcodes
@@ -68,68 +89,130 @@ impl ThreadConditions {
     }
 
     // To implement Wait / Notify, a HasMap, behind a mutex, will be used
-    // to track the address of waiter. The key of the hashmap is based on the memory
-    // and waiter threads are "park"'d (with or without timeout)
-    // Notify will wake the waiters by simply "unpark" the thread
-    // as the Thread info is stored on the HashMap
-    // once unparked, the waiter thread will remove it's mark on the HashMap
-    // timeout / awake is tracked with a boolean in the HashMap
-    // because `park_timeout` doesn't gives any information on why it returns
+    // to track the address of waiter. The key of the hashmap is based on the memory.
+    // The actual waiting is implemented with a Condvar + Mutex pair. A Weak is stored
+    // in the hashmap to at least delete the condvar and mutex when there are no
+    // waiters for a given address. Map keys are currently not cleaned up.
 
     /// Add current thread to the waiter hash
-    pub fn do_wait(
+    ///
+    /// # Safety
+    /// If `expected` is [`ExpectedValue::None`], no safety requirements.
+    /// The notify location must have a valid base address that belongs to a memory,
+    /// and the address must be a valid offset within that memory. The offset also
+    /// must be properly aligned for the expected value type; either 4-byte aligned for
+    /// [`ExpectedValue::U32`] or 8-byte aligned for [`ExpectedValue::U64`].
+    pub unsafe fn do_wait(
         &mut self,
         dst: NotifyLocation,
+        expected: ExpectedValue,
         timeout: Option<Duration>,
     ) -> Result<u32, WaiterError> {
         if self.inner.closed.load(std::sync::atomic::Ordering::Acquire) {
             return Err(WaiterError::AtomicsDisabled);
         }
 
-        // 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 {
-            thread: current(),
-            notified: false,
-        });
-        if let Some(timeout) = timeout {
-            park_timeout(timeout);
-        } else {
-            park();
-        }
-        let mut bindding = self.inner.map.get_mut(&dst).unwrap();
-        let v = bindding.value_mut();
-        let id = current().id();
-        let mut ret = 0;
-        v.retain(|cond| {
-            if cond.thread.id() == id {
-                ret = if cond.notified { 0 } else { 2 };
-                false
+
+        // Step 1: lock the map key, so we know no one else can get/create a
+        // different Arc than the one we're getting/creating
+        let entry = self.inner.map.entry(dst.address);
+        let ref_mut = entry.or_default();
+        let arc = ref_mut.clone();
+
+        // Step 2: lock the mutex while still holding the map lock, so nobody
+        // can delete the map key or make a new Arc
+        let mut mutex_guard = arc.0.lock();
+
+        // Step 3: unlock the map key, we don't need it anymore.
+        drop(ref_mut);
+
+        // Once we lock the mutex, we can check the expected value. A notifying
+        // thread will have written an updated value to the address *before*
+        // doing the notify call, and the call has to acquire the same lock we're
+        // holding. This means we can't miss an update to the expected value that
+        // would prevent us from sleeping.
+        // This logic mirrors how the linux kernel's futex syscall works, so see
+        // the documentation on that if I made zero sense here.
+
+        // Safety: the function's safety contract ensures that the memory location is valid
+        // and can be dereferenced.
+        let should_sleep = match expected {
+            ExpectedValue::None => true,
+            ExpectedValue::U32(expected_val) => unsafe {
+                let src = dst.memory_base.offset(dst.address as isize) as *mut u32;
+                let atomic_src = AtomicPtr::new(src);
+                let read_val = *atomic_src.load(Ordering::Acquire);
+                read_val == expected_val
+            },
+            ExpectedValue::U64(expected_val) => unsafe {
+                let src = dst.memory_base.offset(dst.address as isize) as *mut u64;
+                let atomic_src = AtomicPtr::new(src);
+                let read_val = *atomic_src.load(Ordering::Acquire);
+                read_val == expected_val
+            },
+        };
+
+        let ret = if should_sleep {
+            *mutex_guard += 1;
+
+            let ret = if let Some(timeout) = timeout {
+                let timeout = arc.1.wait_for(&mut mutex_guard, timeout);
+                if timeout.timed_out() {
+                    2 // timeout
+                } else {
+                    0 // notified
+                }
             } else {
-                true
+                arc.1.wait(&mut mutex_guard);
+                0
+            };
+
+            *mutex_guard -= 1;
+
+            ret
+        } else {
+            1 // value mismatch
+        };
+
+        {
+            // Note we use two sets of locks; one for the map itself, and one per
+            // wait address. Locking order must stay consistent at all times: map
+            // first, then mutex. So we have to drop the mutex guard here and then
+            // reacquire it after locking the map key to avoid deadlocks.
+            drop(mutex_guard);
+
+            // Same as above, first lock the map key...
+            let entry = self.inner.map.entry(dst.address);
+            if let dashmap::Entry::Occupied(occupied) = entry {
+                // ... then lock the mutex.
+                let arc = occupied.get().clone();
+                let mutex_guard = arc.0.lock();
+
+                if *mutex_guard == 0 {
+                    // No more waiters, remove the map entry.
+                    occupied.remove();
+                }
             }
-        });
-        let empty = v.is_empty();
-        drop(bindding);
-        if empty {
-            self.inner.map.remove(&dst);
         }
+
         Ok(ret)
     }
 
     /// Notify waiters from the wait list
-    pub fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+    pub fn do_notify(&mut self, dst: u32, count: u32) -> u32 {
         let mut count_token = 0u32;
-        if let Some(mut v) = self.inner.map.get_mut(&dst) {
-            for waiter in v.value_mut() {
-                if count_token < count && !waiter.notified {
-                    waiter.notified = true; // waiter was notified, not just an elapsed timeout
-                    waiter.thread.unpark(); // wakeup!
-                    count_token += 1;
+        if let Some(v) = self.inner.map.get(&dst) {
+            let mutex_guard = v.0.lock();
+            for _ in 0..count {
+                if !v.1.notify_one() {
+                    break;
                 }
+                count_token += 1;
             }
+            drop(mutex_guard);
         }
         count_token
     }
@@ -138,10 +221,10 @@ impl ThreadConditions {
     ///
     /// Useful on shutdown to resume execution in all waiters.
     pub fn wake_all_atomic_waiters(&self) {
-        for mut item in self.inner.map.iter_mut() {
-            for waiter in item.value_mut() {
-                waiter.thread.unpark();
-            }
+        for item in self.inner.map.iter_mut() {
+            let arc = item.value();
+            let _mutex_guard = arc.0.lock();
+            arc.1.notify_all();
         }
     }
 
@@ -190,8 +273,7 @@ mod tests {
     #[test]
     fn threadconditions_notify_nowaiters() {
         let mut conditions = ThreadConditions::new();
-        let dst = NotifyLocation { address: 0 };
-        let ret = conditions.do_notify(dst, 1);
+        let ret = conditions.do_notify(0, 1);
         assert_eq!(ret, 0);
     }
 
@@ -203,13 +285,15 @@ mod tests {
         let mut threadcond = conditions.clone();
 
         thread::spawn(move || {
-            let dst = NotifyLocation { address: 0 };
-            let ret = threadcond.do_wait(dst, None).unwrap();
+            let dst = NotifyLocation {
+                address: 0,
+                memory_base: std::ptr::null_mut(),
+            };
+            let ret = unsafe { threadcond.do_wait(dst, ExpectedValue::None, None) }.unwrap();
             assert_eq!(ret, 0);
         });
         thread::sleep(Duration::from_millis(10));
-        let dst = NotifyLocation { address: 0 };
-        let ret = conditions.do_notify(dst, 1);
+        let ret = conditions.do_notify(0, 1);
         assert_eq!(ret, 1);
     }
 
@@ -221,15 +305,19 @@ mod tests {
         let mut threadcond = conditions.clone();
 
         thread::spawn(move || {
-            let dst = NotifyLocation { address: 0 };
-            let ret = threadcond
-                .do_wait(dst, Some(Duration::from_millis(1)))
-                .unwrap();
+            let dst = NotifyLocation {
+                address: 0,
+                memory_base: std::ptr::null_mut(),
+            };
+            let ret = unsafe {
+                threadcond
+                    .do_wait(dst, ExpectedValue::None, Some(Duration::from_millis(1)))
+                    .unwrap()
+            };
             assert_eq!(ret, 2);
         });
         thread::sleep(Duration::from_millis(50));
-        let dst = NotifyLocation { address: 0 };
-        let ret = conditions.do_notify(dst, 1);
+        let ret = conditions.do_notify(0, 1);
         assert_eq!(ret, 0);
     }
 
@@ -241,15 +329,19 @@ mod tests {
         let mut threadcond = conditions.clone();
 
         thread::spawn(move || {
-            let dst = NotifyLocation { address: 8 };
-            let ret = threadcond
-                .do_wait(dst, Some(Duration::from_millis(10)))
-                .unwrap();
+            let dst = NotifyLocation {
+                address: 8,
+                memory_base: std::ptr::null_mut(),
+            };
+            let ret = unsafe {
+                threadcond
+                    .do_wait(dst, ExpectedValue::None, Some(Duration::from_millis(10)))
+                    .unwrap()
+            };
             assert_eq!(ret, 2);
         });
         thread::sleep(Duration::from_millis(1));
-        let dst = NotifyLocation { address: 0 };
-        let ret = conditions.do_notify(dst, 1);
+        let ret = conditions.do_notify(0, 1);
         assert_eq!(ret, 0);
         thread::sleep(Duration::from_millis(100));
     }
@@ -263,18 +355,39 @@ mod tests {
         let mut threadcond2 = conditions.clone();
 
         thread::spawn(move || {
-            let dst = NotifyLocation { address: 0 };
-            let ret = threadcond.do_wait(dst, None).unwrap();
+            let dst = NotifyLocation {
+                address: 0,
+                memory_base: std::ptr::null_mut(),
+            };
+            let ret = unsafe { threadcond.do_wait(dst, ExpectedValue::None, None).unwrap() };
             assert_eq!(ret, 0);
         });
         thread::spawn(move || {
-            let dst = NotifyLocation { address: 0 };
-            let ret = threadcond2.do_wait(dst, None).unwrap();
+            let dst = NotifyLocation {
+                address: 0,
+                memory_base: std::ptr::null_mut(),
+            };
+            let ret = unsafe { threadcond2.do_wait(dst, ExpectedValue::None, None).unwrap() };
             assert_eq!(ret, 0);
         });
         thread::sleep(Duration::from_millis(20));
-        let dst = NotifyLocation { address: 0 };
-        let ret = conditions.do_notify(dst, 5);
+        let ret = conditions.do_notify(0, 5);
         assert_eq!(ret, 2);
     }
+
+    #[test]
+    fn threadconditions_value_mismatch() {
+        let mut conditions = ThreadConditions::new();
+        let mut data: u32 = 42;
+        let dst = NotifyLocation {
+            address: 0,
+            memory_base: (&mut data as *mut u32) as *mut u8,
+        };
+        let ret = unsafe {
+            conditions
+                .do_wait(dst, ExpectedValue::U32(85), Some(Duration::from_millis(10)))
+                .unwrap()
+        };
+        assert_eq!(ret, 1);
+    }
 }
diff --git a/lib/vm/src/trap/mod.rs b/lib/vm/src/trap/mod.rs
index e329259324..5cee47b812 100644
--- a/lib/vm/src/trap/mod.rs
+++ b/lib/vm/src/trap/mod.rs
@@ -10,8 +10,8 @@ mod traphandlers;
 
 pub use trap::Trap;
 pub use traphandlers::{
-    catch_traps, on_host_stack, raise_lib_trap, raise_user_trap, set_stack_size,
-    wasmer_call_trampoline, TrapHandlerFn, VMConfig,
+    TrapHandlerFn, VMConfig, catch_traps, on_host_stack, raise_lib_trap, raise_user_trap,
+    set_stack_size, wasmer_call_trampoline,
 };
 pub use traphandlers::{init_traps, resume_panic};
 pub use wasmer_types::TrapCode;
diff --git a/lib/vm/src/trap/trap.rs b/lib/vm/src/trap/trap.rs
index fa8de9c939..9d7117d1ff 100644
--- a/lib/vm/src/trap/trap.rs
+++ b/lib/vm/src/trap/trap.rs
@@ -3,6 +3,8 @@ use std::error::Error;
 use std::fmt;
 use wasmer_types::TrapCode;
 
+use crate::{StoreObjects, VMExceptionRef};
+
 /// Stores trace message with backtrace.
 #[derive(Debug)]
 pub enum Trap {
@@ -38,6 +40,15 @@ pub enum Trap {
         /// Native stack backtrace at the time the OOM occurred
         backtrace: Backtrace,
     },
+
+    /// A WASM exception was thrown but not caught.
+    UncaughtException {
+        /// The exception reference of the uncaught exception.
+        exnref: VMExceptionRef,
+        /// Native stack backtrace at the time the exception was thrown.
+        /// This is a clone of the backtrace stored in the exception itself.
+        backtrace: Backtrace,
+    },
 }
 
 fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) {
@@ -87,6 +98,14 @@ impl Trap {
         Self::OOM { backtrace }
     }
 
+    /// Construct a new UncaughtException trap with the given exception reference.
+    pub fn uncaught_exception(exnref: VMExceptionRef, ctx: &StoreObjects) -> Self {
+        Self::UncaughtException {
+            backtrace: exnref.0.get(ctx).backtrace().clone(),
+            exnref,
+        }
+    }
+
     /// Attempts to downcast the `Trap` to a concrete type.
     pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
         match self {
@@ -112,6 +131,22 @@ impl Trap {
             _ => false,
         }
     }
+
+    /// Returns true if the trap is an exception
+    pub fn is_exception(&self) -> bool {
+        matches!(self, Self::UncaughtException { .. })
+    }
+
+    /// If the `Trap` is an uncaught exception, returns it.
+    pub fn to_exception_ref(&self) -> Option<VMExceptionRef> {
+        match self {
+            // Self::UncaughtException { exnref, .. } => Some(Exception::from_vm_exceptionref(
+            //     crate::vm::VMExceptionRef::Sys(exnref.clone()),
+            // )),
+            Self::UncaughtException { exnref, .. } => Some(exnref.clone()),
+            _ => None,
+        }
+    }
 }
 
 impl std::error::Error for Trap {
@@ -126,10 +161,11 @@ 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"),
+            Self::UncaughtException { .. } => write!(f, "Uncaught wasm exception"),
         }
     }
 }
diff --git a/lib/vm/src/trap/traphandlers.rs b/lib/vm/src/trap/traphandlers.rs
index 4ce892db0a..00d3366686 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;
@@ -20,14 +22,14 @@ use std::mem;
 #[cfg(unix)]
 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::atomic::{AtomicPtr, AtomicUsize, Ordering, compiler_fence};
+use std::sync::{LazyLock, Once};
 use wasmer_types::TrapCode;
 
 /// Configuration for the runtime VM
 /// Currently only the stack size is configurable
 pub struct VMConfig {
-    /// Optionnal stack size (in byte) of the VM. Value lower than 8K will be rounded to 8K.
+    /// Optional stack size (in byte) of the VM. Value lower than 8K will be rounded to 8K.
     pub wasm_stack_size: Option<usize>,
 }
 
@@ -52,30 +54,12 @@ struct ucontext_t {
     uc_mcontext: libc::mcontext_t,
 }
 
-// Current definition of `ucontext_t` in the `libc` crate is not present
-// on aarch64-unknown-freebsd so it's defined here.
-#[repr(C)]
-#[cfg(all(target_arch = "aarch64", target_os = "freebsd"))]
-#[allow(non_camel_case_types)]
-struct ucontext_t {
-    uc_sigmask: libc::sigset_t,
-    uc_mcontext: libc::mcontext_t,
-    uc_link: *mut ucontext_t,
-    uc_stack: libc::stack_t,
-    uc_flags: libc::c_int,
-    spare: [libc::c_int; 4],
-}
-
-#[cfg(all(
-    unix,
-    not(all(target_arch = "aarch64", target_os = "macos")),
-    not(all(target_arch = "aarch64", target_os = "freebsd"))
-))]
+#[cfg(all(unix, not(all(target_arch = "aarch64", target_os = "macos"))))]
 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! {
@@ -91,32 +75,56 @@ cfg_if::cfg_if! {
 // Process an IllegalOpcode to see if it has a TrapCode payload
 unsafe fn process_illegal_op(addr: usize) -> Option<TrapCode> {
     let mut val: Option<u8> = None;
-    if cfg!(target_arch = "x86_64") {
-        val = if read(addr as *mut u8) & 0xf0 == 0x40
-            && read((addr + 1) as *mut u8) == 0x0f
-            && read((addr + 2) as *mut u8) == 0xb9
-        {
-            Some(read((addr + 3) as *mut u8))
-        } else if read(addr as *mut u8) == 0x0f && read((addr + 1) as *mut u8) == 0xb9 {
-            Some(read((addr + 2) as *mut u8))
-        } else {
-            None
+    unsafe {
+        if cfg!(target_arch = "x86_64") {
+            val = if read(addr as *mut u8) & 0xf0 == 0x40
+                && read((addr + 1) as *mut u8) == 0x0f
+                && read((addr + 2) as *mut u8) == 0xb9
+            {
+                Some(read((addr + 3) as *mut u8))
+            } else if read(addr as *mut u8) == 0x0f && read((addr + 1) as *mut u8) == 0xb9 {
+                Some(read((addr + 2) as *mut u8))
+            } else {
+                None
+            }
         }
-    }
-    if cfg!(target_arch = "aarch64") {
-        val = if read_unaligned(addr as *mut u32) & 0xffff0000 == 0 {
-            Some(read(addr as *mut u8))
-        } else {
-            None
+        if cfg!(target_arch = "aarch64") {
+            val = if read_unaligned(addr as *mut u32) & 0xffff0000 == 0 {
+                Some(read(addr as *mut u8))
+            } else {
+                None
+            }
         }
-    }
-    match val.and_then(|val| {
-        if val & MAGIC == MAGIC {
-            Some(val & 0xf)
-        } else {
-            None
+        if cfg!(target_arch = "riscv64") {
+            let addr = addr as *mut u32;
+            // Check if 'unimp' instruction
+            val = if read(addr) == 0xc0001073 {
+                // Read from the instruction we emitted: 'addi a0, xzero, $payload'
+                // and take the encoded immediate value (upper 12-bits).
+                let prev_insn = read(addr.sub(1));
+                if (prev_insn & 0xffff) == 0x0513 {
+                    Some((prev_insn >> 20) as u8)
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
         }
-    }) {
+    }
+
+    // The direct encoding of a trap into the instruction is unused on RISC-V:
+    if cfg!(target_arch = "x86_64") || cfg!(target_arch = "aarch64") {
+        val = val.and_then(|val| {
+            if val & MAGIC == MAGIC {
+                Some(val & 0xf)
+            } else {
+                None
+            }
+        });
+    }
+
+    match val {
         None => None,
         Some(val) => match val {
             0 => Some(TrapCode::StackOverflow),
@@ -142,7 +150,7 @@ cfg_if::cfg_if! {
         static mut PREV_SIGILL: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
         static mut PREV_SIGFPE: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
 
-        unsafe fn platform_init() {
+        unsafe fn platform_init() { unsafe {
             let register = |slot: &mut MaybeUninit<libc::sigaction>, signal: i32| {
                 let mut handler: libc::sigaction = mem::zeroed();
                 // The flags here are relatively careful, and they are...
@@ -159,7 +167,7 @@ cfg_if::cfg_if! {
                 // crash while handling the signal, and fall through to the
                 // Breakpad handler by testing handlingSegFault.
                 handler.sa_flags = libc::SA_SIGINFO | libc::SA_NODEFER | libc::SA_ONSTACK;
-                handler.sa_sigaction = trap_handler as usize;
+                handler.sa_sigaction = trap_handler as *const () as usize;
                 libc::sigemptyset(&mut handler.sa_mask);
                 if libc::sigaction(signal, &handler, slot.as_mut_ptr()) != 0 {
                     panic!(
@@ -197,7 +205,7 @@ cfg_if::cfg_if! {
                 use mach2::traps::*;
                 use mach2::mach_types::*;
 
-                extern "C" {
+                unsafe extern "C" {
                     fn task_set_exception_ports(
                         task: task_t,
                         exception_mask: exception_mask_t,
@@ -222,19 +230,19 @@ cfg_if::cfg_if! {
                     MACHINE_THREAD_STATE,
                 );
             }
-        }
+        }}
 
         unsafe extern "C" fn trap_handler(
             signum: libc::c_int,
             siginfo: *mut libc::siginfo_t,
             context: *mut libc::c_void,
-        ) {
+        ) { unsafe {
             let previous = match signum {
                 libc::SIGSEGV => &PREV_SIGSEGV,
                 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 {
@@ -289,7 +297,7 @@ cfg_if::cfg_if! {
                     previous.sa_sigaction
                 )(signum)
             }
-        }
+        }}
 
         unsafe fn get_pc_sp(context: &ucontext_t) -> (usize, usize) {
             let (pc, sp);
@@ -313,8 +321,9 @@ cfg_if::cfg_if! {
                     pc = context.uc_mcontext.mc_rip as usize;
                     sp = context.uc_mcontext.mc_rsp as usize;
                 } else if #[cfg(all(target_vendor = "apple", target_arch = "x86_64"))] {
-                    pc = (*context.uc_mcontext).__ss.__rip as usize;
-                    sp = (*context.uc_mcontext).__ss.__rsp as usize;
+                    let mcontext = unsafe { &*context.uc_mcontext };
+                    pc = mcontext.__ss.__rip as usize;
+                    sp = mcontext.__ss.__rsp as usize;
                 } else if #[cfg(all(
                         any(target_os = "linux", target_os = "android"),
                         target_arch = "aarch64",
@@ -334,11 +343,18 @@ cfg_if::cfg_if! {
                     pc = context.uc_mcontext.__gregs[libc::REG_PC] as usize;
                     sp = context.uc_mcontext.__gregs[libc::REG_SP] as usize;
                 } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64"))] {
-                    pc = (*context.uc_mcontext).__ss.__pc as usize;
-                    sp = (*context.uc_mcontext).__ss.__sp as usize;
+                    let mcontext = unsafe { &*context.uc_mcontext };
+                    pc = mcontext.__ss.__pc as usize;
+                    sp = mcontext.__ss.__sp as usize;
                 } 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 if #[cfg(all(target_os = "linux", target_arch = "powerpc64"))] {
+                    pc = (*context.uc_mcontext.regs).nip as usize;
+                    sp = (*context.uc_mcontext.regs).gpr[1] as usize;
                 } else {
                     compile_error!("Unsupported platform");
                 }
@@ -370,11 +386,12 @@ cfg_if::cfg_if! {
                     context.uc_mcontext.gregs[libc::REG_EDX as usize] = edx as i32;
                 } else if #[cfg(all(target_vendor = "apple", target_arch = "x86_64"))] {
                     let TrapHandlerRegs { rip, rsp, rbp, rdi, rsi } = regs;
-                    (*context.uc_mcontext).__ss.__rip = rip;
-                    (*context.uc_mcontext).__ss.__rsp = rsp;
-                    (*context.uc_mcontext).__ss.__rbp = rbp;
-                    (*context.uc_mcontext).__ss.__rdi = rdi;
-                    (*context.uc_mcontext).__ss.__rsi = rsi;
+                    let mcontext = unsafe { &mut *context.uc_mcontext };
+                    mcontext.__ss.__rip = rip;
+                    mcontext.__ss.__rsp = rsp;
+                    mcontext.__ss.__rbp = rbp;
+                    mcontext.__ss.__rdi = rdi;
+                    mcontext.__ss.__rsi = rsi;
                 } else if #[cfg(all(target_os = "freebsd", target_arch = "x86"))] {
                     let TrapHandlerRegs { eip, esp, ebp, ecx, edx } = regs;
                     context.uc_mcontext.mc_eip = eip as libc::register_t;
@@ -445,12 +462,13 @@ cfg_if::cfg_if! {
                     context.uc_mcontext.__gregs[libc::REG_S0] = s0 as libc::c_ulong;
                 } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64"))] {
                     let TrapHandlerRegs { pc, sp, x0, x1, x29, lr } = regs;
-                    (*context.uc_mcontext).__ss.__pc = pc;
-                    (*context.uc_mcontext).__ss.__sp = sp;
-                    (*context.uc_mcontext).__ss.__x[0] = x0;
-                    (*context.uc_mcontext).__ss.__x[1] = x1;
-                    (*context.uc_mcontext).__ss.__fp = x29;
-                    (*context.uc_mcontext).__ss.__lr = lr;
+                    let mcontext = unsafe { &mut *context.uc_mcontext };
+                    mcontext.__ss.__pc = pc;
+                    mcontext.__ss.__sp = sp;
+                    mcontext.__ss.__x[0] = x0;
+                    mcontext.__ss.__x[1] = x1;
+                    mcontext.__ss.__fp = x29;
+                    mcontext.__ss.__lr = lr;
                 } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
                     let TrapHandlerRegs { pc, sp, x0, x1, x29, lr } = regs;
                     context.uc_mcontext.mc_gpregs.gp_elr = pc as libc::register_t;
@@ -458,7 +476,23 @@ cfg_if::cfg_if! {
                     context.uc_mcontext.mc_gpregs.gp_x[0] = x0 as libc::register_t;
                     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;
+                    context.uc_mcontext.mc_gpregs.gp_lr = 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 if #[cfg(all(target_os = "linux", target_arch = "powerpc64"))] {
+                    let TrapHandlerRegs { pc, sp, r3, r4, r31, lr } = regs;
+                    (*context.uc_mcontext.regs).nip = pc;
+                    (*context.uc_mcontext.regs).gpr[1] = sp;
+                    (*context.uc_mcontext.regs).gpr[3] = r3;
+                    (*context.uc_mcontext.regs).gpr[4] = r4;
+                    (*context.uc_mcontext.regs).gpr[31] = r31;
+                    (*context.uc_mcontext.regs).link = lr;
                 } else {
                     compile_error!("Unsupported platform");
                 }
@@ -481,73 +515,78 @@ cfg_if::cfg_if! {
         };
 
         unsafe fn platform_init() {
-            // our trap handler needs to go first, so that we can recover from
-            // wasm faults and continue execution, so pass `1` as a true value
-            // here.
-            if AddVectoredExceptionHandler(1, Some(exception_handler)).is_null() {
-                panic!("failed to add exception handler: {}", io::Error::last_os_error());
+            unsafe {
+                // our trap handler needs to go first, so that we can recover from
+                // wasm faults and continue execution, so pass `1` as a true value
+                // here.
+                let handler = AddVectoredExceptionHandler(1, Some(exception_handler));
+                if handler.is_null() {
+                    panic!("failed to add exception handler: {}", io::Error::last_os_error());
+                }
             }
         }
 
         unsafe extern "system" fn exception_handler(
             exception_info: *mut EXCEPTION_POINTERS
         ) -> i32 {
-            // Check the kind of exception, since we only handle a subset within
-            // wasm code. If anything else happens we want to defer to whatever
-            // the rest of the system wants to do for this exception.
-            let record = &*(*exception_info).ExceptionRecord;
-            if record.ExceptionCode != EXCEPTION_ACCESS_VIOLATION &&
-                record.ExceptionCode != EXCEPTION_ILLEGAL_INSTRUCTION &&
-                record.ExceptionCode != EXCEPTION_STACK_OVERFLOW &&
-                record.ExceptionCode != EXCEPTION_INT_DIVIDE_BY_ZERO &&
-                record.ExceptionCode != EXCEPTION_INT_OVERFLOW
-            {
-                return EXCEPTION_CONTINUE_SEARCH;
-            }
-
-            // FIXME: this is what the previous C++ did to make sure that TLS
-            // works by the time we execute this trap handling code. This isn't
-            // exactly super easy to call from Rust though and it's not clear we
-            // necessarily need to do so. Leaving this here in case we need this
-            // in the future, but for now we can probably wait until we see a
-            // strange fault before figuring out how to reimplement this in
-            // Rust.
-            //
-            // if (!NtCurrentTeb()->Reserved1[sThreadLocalArrayPointerIndex]) {
-            //     return EXCEPTION_CONTINUE_SEARCH;
-            // }
+            unsafe {
+                // Check the kind of exception, since we only handle a subset within
+                // wasm code. If anything else happens we want to defer to whatever
+                // the rest of the system wants to do for this exception.
+                let record = &*(*exception_info).ExceptionRecord;
+                if record.ExceptionCode != EXCEPTION_ACCESS_VIOLATION &&
+                    record.ExceptionCode != EXCEPTION_ILLEGAL_INSTRUCTION &&
+                    record.ExceptionCode != EXCEPTION_STACK_OVERFLOW &&
+                    record.ExceptionCode != EXCEPTION_INT_DIVIDE_BY_ZERO &&
+                    record.ExceptionCode != EXCEPTION_INT_OVERFLOW
+                {
+                    return EXCEPTION_CONTINUE_SEARCH;
+                }
 
-            let context = &mut *(*exception_info).ContextRecord;
-            let (pc, sp) = get_pc_sp(context);
+                // FIXME: this is what the previous C++ did to make sure that TLS
+                // works by the time we execute this trap handling code. This isn't
+                // exactly super easy to call from Rust though and it's not clear we
+                // necessarily need to do so. Leaving this here in case we need this
+                // in the future, but for now we can probably wait until we see a
+                // strange fault before figuring out how to reimplement this in
+                // Rust.
+                //
+                // if (!NtCurrentTeb()->Reserved1[sThreadLocalArrayPointerIndex]) {
+                //     return EXCEPTION_CONTINUE_SEARCH;
+                // }
+
+                let context = &mut *(*exception_info).ContextRecord;
+                let (pc, sp) = get_pc_sp(context);
+
+                // We try to get the fault address associated to this exception.
+                let maybe_fault_address = match record.ExceptionCode {
+                    EXCEPTION_ACCESS_VIOLATION => Some(record.ExceptionInformation[1]),
+                    EXCEPTION_STACK_OVERFLOW => Some(sp),
+                    _ => None,
+                };
+                let trap_code = match record.ExceptionCode {
+                    // check if it was cased by a UD and if the Trap info is a payload to it
+                    EXCEPTION_ILLEGAL_INSTRUCTION => {
+                        process_illegal_op(pc)
+                    }
+                    _ => None,
+                };
+                // This is basically the same as the unix version above, only with a
+                // few parameters tweaked here and there.
+                let handled = TrapHandlerContext::handle_trap(
+                    pc,
+                    sp,
+                    maybe_fault_address,
+                    trap_code,
+                    |regs| update_context(context, regs),
+                    |handler| handler(exception_info),
+                );
 
-            // We try to get the fault address associated to this exception.
-            let maybe_fault_address = match record.ExceptionCode {
-                EXCEPTION_ACCESS_VIOLATION => Some(record.ExceptionInformation[1]),
-                EXCEPTION_STACK_OVERFLOW => Some(sp),
-                _ => None,
-            };
-            let trap_code = match record.ExceptionCode {
-                // check if it was cased by a UD and if the Trap info is a payload to it
-                EXCEPTION_ILLEGAL_INSTRUCTION => {
-                    process_illegal_op(pc)
+                if handled {
+                    EXCEPTION_CONTINUE_EXECUTION
+                } else {
+                    EXCEPTION_CONTINUE_SEARCH
                 }
-                _ => None,
-            };
-            // This is basically the same as the unix version above, only with a
-            // few parameters tweaked here and there.
-            let handled = TrapHandlerContext::handle_trap(
-                pc,
-                sp,
-                maybe_fault_address,
-                trap_code,
-                |regs| update_context(context, regs),
-                |handler| handler(exception_info),
-            );
-
-            if handled {
-                EXCEPTION_CONTINUE_EXECUTION
-            } else {
-                EXCEPTION_CONTINUE_SEARCH
             }
         }
 
@@ -619,7 +658,7 @@ pub fn init_traps() {
 /// Additionally no Rust destructors may be on the stack.
 /// They will be skipped and not executed.
 pub unsafe fn raise_user_trap(data: Box<dyn Error + Send + Sync>) -> ! {
-    unwind_with(UnwindReason::UserTrap(data))
+    unsafe { unwind_with(UnwindReason::UserTrap(data)) }
 }
 
 /// Raises a trap from inside library code immediately.
@@ -634,7 +673,7 @@ pub unsafe fn raise_user_trap(data: Box<dyn Error + Send + Sync>) -> ! {
 /// Additionally no Rust destructors may be on the stack.
 /// They will be skipped and not executed.
 pub unsafe fn raise_lib_trap(trap: Trap) -> ! {
-    unwind_with(UnwindReason::LibTrap(trap))
+    unsafe { unwind_with(UnwindReason::LibTrap(trap)) }
 }
 
 /// Carries a Rust panic across wasm code and resumes the panic on the other
@@ -646,7 +685,7 @@ pub unsafe fn raise_lib_trap(trap: Trap) -> ! {
 /// have been previously called and not returned. Additionally no Rust destructors may be on the
 /// stack. They will be skipped and not executed.
 pub unsafe fn resume_panic(payload: Box<dyn Any + Send>) -> ! {
-    unwind_with(UnwindReason::Panic(payload))
+    unsafe { unwind_with(UnwindReason::Panic(payload)) }
 }
 
 /// Call the wasm function pointed to by `callee`.
@@ -672,11 +711,18 @@ 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);
-    })
+    unsafe {
+        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);
+        })
+    }
 }
 
 /// Catches any wasm traps that happen within the execution of `closure`,
@@ -685,13 +731,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 +756,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
@@ -793,28 +839,30 @@ impl TrapHandlerContext {
         mut update_regs: impl FnMut(TrapHandlerRegs),
         call_handler: impl Fn(&TrapHandlerFn<'static>) -> bool,
     ) -> bool {
-        let ptr = TRAP_HANDLER.with(|ptr| ptr.load(Ordering::Relaxed));
-        if ptr.is_null() {
-            return false;
-        }
+        unsafe {
+            let ptr = TRAP_HANDLER.with(|ptr| ptr.load(Ordering::Relaxed));
+            if ptr.is_null() {
+                return false;
+            }
 
-        let ctx = &*ptr;
+            let ctx = &*ptr;
 
-        // Check if this trap is handled by a custom trap handler.
-        if let Some(trap_handler) = ctx.custom_trap {
-            if call_handler(&*trap_handler) {
+            // Check if this trap is handled by a custom trap handler.
+            if let Some(trap_handler) = ctx.custom_trap
+                && call_handler(&*trap_handler)
+            {
                 return true;
             }
-        }
 
-        (ctx.handle_trap)(
-            ctx.inner,
-            pc,
-            sp,
-            maybe_fault_address,
-            trap_code,
-            &mut update_regs,
-        )
+            (ctx.handle_trap)(
+                ctx.inner,
+                pc,
+                sp,
+                maybe_fault_address,
+                trap_code,
+                &mut update_regs,
+            )
+        }
     }
 }
 
@@ -827,46 +875,48 @@ impl<T> TrapHandlerContextInner<T> {
         trap_code: Option<TrapCode>,
         update_regs: &mut dyn FnMut(TrapHandlerRegs),
     ) -> bool {
-        // Check if this trap occurred while executing on the Wasm stack. We can
-        // only recover from traps if that is the case.
-        if !self.coro_trap_handler.stack_ptr_in_bounds(sp) {
-            return false;
-        }
+        unsafe {
+            // Check if this trap occurred while executing on the Wasm stack. We can
+            // only recover from traps if that is the case.
+            if !self.coro_trap_handler.stack_ptr_in_bounds(sp) {
+                return false;
+            }
 
-        let signal_trap = trap_code.or_else(|| {
-            maybe_fault_address.map(|addr| {
-                if self.coro_trap_handler.stack_ptr_in_bounds(addr) {
-                    TrapCode::StackOverflow
-                } else {
-                    TrapCode::HeapAccessOutOfBounds
-                }
-            })
-        });
+            let signal_trap = trap_code.or_else(|| {
+                maybe_fault_address.map(|addr| {
+                    if self.coro_trap_handler.stack_ptr_in_bounds(addr) {
+                        TrapCode::StackOverflow
+                    } else {
+                        TrapCode::HeapAccessOutOfBounds
+                    }
+                })
+            });
 
-        // Don't try to generate a backtrace for stack overflows: unwinding
-        // information is often not precise enough to properly describe what is
-        // happenning during a function prologue, which can lead the unwinder to
-        // read invalid memory addresses.
-        //
-        // See: https://github.com/rust-lang/backtrace-rs/pull/357
-        let backtrace = if signal_trap == Some(TrapCode::StackOverflow) {
-            Backtrace::from(vec![])
-        } else {
-            Backtrace::new_unresolved()
-        };
+            // Don't try to generate a backtrace for stack overflows: unwinding
+            // information is often not precise enough to properly describe what is
+            // happenning during a function prologue, which can lead the unwinder to
+            // read invalid memory addresses.
+            //
+            // See: https://github.com/rust-lang/backtrace-rs/pull/357
+            let backtrace = if signal_trap == Some(TrapCode::StackOverflow) {
+                Backtrace::from(vec![])
+            } else {
+                Backtrace::new_unresolved()
+            };
 
-        // Set up the register state for exception return to force the
-        // coroutine to return to its caller with UnwindReason::WasmTrap.
-        let unwind = UnwindReason::WasmTrap {
-            backtrace,
-            signal_trap,
-            pc,
-        };
-        let regs = self
-            .coro_trap_handler
-            .setup_trap_handler(move || Err(unwind));
-        update_regs(regs);
-        true
+            // Set up the register state for exception return to force the
+            // coroutine to return to its caller with UnwindReason::WasmTrap.
+            let unwind = UnwindReason::WasmTrap {
+                backtrace,
+                signal_trap,
+                pc,
+            };
+            let regs = self
+                .coro_trap_handler
+                .setup_trap_handler(move || Err(unwind));
+            update_regs(regs);
+            true
+        }
     }
 }
 
@@ -901,20 +951,22 @@ impl UnwindReason {
 }
 
 unsafe fn unwind_with(reason: UnwindReason) -> ! {
-    let yielder = YIELDER
-        .with(|cell| cell.replace(None))
-        .expect("not running on Wasm stack");
+    unsafe {
+        let yielder = YIELDER
+            .with(|cell| cell.replace(None))
+            .expect("not running on Wasm stack");
 
-    yielder.as_ref().suspend(reason);
+        yielder.as_ref().suspend(reason);
 
-    // on_wasm_stack will forcibly reset the coroutine stack after yielding.
-    unreachable!();
+        // on_wasm_stack will forcibly reset the coroutine stack after yielding.
+        unreachable!();
+    }
 }
 
 /// 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 +975,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 +996,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,
-        }
+        })
     })
 }
 
@@ -1041,53 +1095,55 @@ pub fn lazy_per_thread_init() -> Result<(), Trap> {
     }
 
     unsafe fn init_sigstack() -> Tls {
-        // Check to see if the existing sigaltstack, if it exists, is big
-        // enough. If so we don't need to allocate our own.
-        let mut old_stack = mem::zeroed();
-        let r = libc::sigaltstack(ptr::null(), &mut old_stack);
-        assert_eq!(r, 0, "learning about sigaltstack failed");
-        if old_stack.ss_flags & libc::SS_DISABLE == 0 && old_stack.ss_size >= MIN_STACK_SIZE {
-            return Tls::BigEnough;
-        }
+        unsafe {
+            // Check to see if the existing sigaltstack, if it exists, is big
+            // enough. If so we don't need to allocate our own.
+            let mut old_stack = mem::zeroed();
+            let r = libc::sigaltstack(ptr::null(), &mut old_stack);
+            assert_eq!(r, 0, "learning about sigaltstack failed");
+            if old_stack.ss_flags & libc::SS_DISABLE == 0 && old_stack.ss_size >= MIN_STACK_SIZE {
+                return Tls::BigEnough;
+            }
 
-        // ... but failing that we need to allocate our own, so do all that
-        // here.
-        let page_size: usize = region::page::size();
-        let guard_size = page_size;
-        let alloc_size = guard_size + MIN_STACK_SIZE;
-
-        let ptr = libc::mmap(
-            null_mut(),
-            alloc_size,
-            libc::PROT_NONE,
-            libc::MAP_PRIVATE | libc::MAP_ANON,
-            -1,
-            0,
-        );
-        if ptr == libc::MAP_FAILED {
-            return Tls::OutOfMemory;
-        }
+            // ... but failing that we need to allocate our own, so do all that
+            // here.
+            let page_size: usize = region::page::size();
+            let guard_size = page_size;
+            let alloc_size = guard_size + MIN_STACK_SIZE;
+
+            let ptr = libc::mmap(
+                null_mut(),
+                alloc_size,
+                libc::PROT_NONE,
+                libc::MAP_PRIVATE | libc::MAP_ANON,
+                -1,
+                0,
+            );
+            if ptr == libc::MAP_FAILED {
+                return Tls::OutOfMemory;
+            }
 
-        // Prepare the stack with readable/writable memory and then register it
-        // with `sigaltstack`.
-        let stack_ptr = (ptr as usize + guard_size) as *mut libc::c_void;
-        let r = libc::mprotect(
-            stack_ptr,
-            MIN_STACK_SIZE,
-            libc::PROT_READ | libc::PROT_WRITE,
-        );
-        assert_eq!(r, 0, "mprotect to configure memory for sigaltstack failed");
-        let new_stack = libc::stack_t {
-            ss_sp: stack_ptr,
-            ss_flags: 0,
-            ss_size: MIN_STACK_SIZE,
-        };
-        let r = libc::sigaltstack(&new_stack, ptr::null_mut());
-        assert_eq!(r, 0, "registering new sigaltstack failed");
+            // Prepare the stack with readable/writable memory and then register it
+            // with `sigaltstack`.
+            let stack_ptr = (ptr as usize + guard_size) as *mut libc::c_void;
+            let r = libc::mprotect(
+                stack_ptr,
+                MIN_STACK_SIZE,
+                libc::PROT_READ | libc::PROT_WRITE,
+            );
+            assert_eq!(r, 0, "mprotect to configure memory for sigaltstack failed");
+            let new_stack = libc::stack_t {
+                ss_sp: stack_ptr,
+                ss_flags: 0,
+                ss_size: MIN_STACK_SIZE,
+            };
+            let r = libc::sigaltstack(&new_stack, ptr::null_mut());
+            assert_eq!(r, 0, "registering new sigaltstack failed");
 
-        Tls::Allocated {
-            mmap_ptr: ptr,
-            mmap_size: alloc_size,
+            Tls::Allocated {
+                mmap_ptr: ptr,
+                mmap_size: alloc_size,
+            }
         }
     }
 
diff --git a/lib/vm/src/vmcontext.rs b/lib/vm/src/vmcontext.rs
index c75d6b5f69..b6967c13f1 100644
--- a/lib/vm/src/vmcontext.rs
+++ b/lib/vm/src/vmcontext.rs
@@ -4,18 +4,18 @@
 //! This file declares `VMContext` and several related structs which contain
 //! fields that compiled wasm code accesses directly.
 
+use crate::VMFunctionBody;
+use crate::VMTable;
 use crate::global::VMGlobal;
 use crate::instance::Instance;
 use crate::memory::VMMemory;
 use crate::store::InternalStoreHandle;
 use crate::trap::{Trap, TrapCode};
-use crate::VMFunctionBody;
-use crate::VMTable;
 use crate::{VMBuiltinFunctionIndex, VMFunction};
 use std::convert::TryFrom;
+use std::hash::{Hash, Hasher};
 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.
@@ -48,7 +48,7 @@ impl std::fmt::Debug for VMFunctionContext {
 
 impl std::cmp::PartialEq for VMFunctionContext {
     fn eq(&self, rhs: &Self) -> bool {
-        unsafe { self.host_env as usize == rhs.host_env as usize }
+        unsafe { std::ptr::eq(self.host_env, rhs.host_env) }
     }
 }
 
@@ -321,27 +321,29 @@ pub(crate) unsafe fn memory_copy(
     src: u32,
     len: u32,
 ) -> Result<(), Trap> {
-    // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
-    if src
-        .checked_add(len)
-        .map_or(true, |n| usize::try_from(n).unwrap() > mem.current_length)
-        || dst
+    unsafe {
+        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
+        if src
             .checked_add(len)
-            .map_or(true, |m| usize::try_from(m).unwrap() > mem.current_length)
-    {
-        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
-    }
+            .is_none_or(|n| usize::try_from(n).unwrap() > mem.current_length)
+            || dst
+                .checked_add(len)
+                .is_none_or(|m| usize::try_from(m).unwrap() > mem.current_length)
+        {
+            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+        }
 
-    let dst = usize::try_from(dst).unwrap();
-    let src = usize::try_from(src).unwrap();
+        let dst = usize::try_from(dst).unwrap();
+        let src = usize::try_from(src).unwrap();
 
-    // Bounds and casts are checked above, by this point we know that
-    // everything is safe.
-    let dst = mem.base.add(dst);
-    let src = mem.base.add(src);
-    ptr::copy(src, dst, len as usize);
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        let dst = mem.base.add(dst);
+        let src = mem.base.add(src);
+        ptr::copy(src, dst, len as usize);
 
-    Ok(())
+        Ok(())
+    }
 }
 
 /// Perform the `memory.fill` operation for the memory in an unsynchronized,
@@ -360,22 +362,24 @@ pub(crate) unsafe fn memory_fill(
     val: u32,
     len: u32,
 ) -> Result<(), Trap> {
-    if dst
-        .checked_add(len)
-        .map_or(true, |m| usize::try_from(m).unwrap() > mem.current_length)
-    {
-        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
-    }
+    unsafe {
+        if dst
+            .checked_add(len)
+            .is_none_or(|m| usize::try_from(m).unwrap() > mem.current_length)
+        {
+            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+        }
 
-    let dst = isize::try_from(dst).unwrap();
-    let val = val as u8;
+        let dst = isize::try_from(dst).unwrap();
+        let val = val as u8;
 
-    // Bounds and casts are checked above, by this point we know that
-    // everything is safe.
-    let dst = mem.base.offset(dst);
-    ptr::write_bytes(dst, val, len as usize);
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        let dst = mem.base.offset(dst);
+        ptr::write_bytes(dst, val, len as usize);
 
-    Ok(())
+        Ok(())
+    }
 }
 
 /// Perform the `memory32.atomic.check32` operation for the memory. Return 0 if same, 1 if different
@@ -391,22 +395,24 @@ pub(crate) unsafe fn memory32_atomic_check32(
     dst: u32,
     val: u32,
 ) -> Result<u32, Trap> {
-    if usize::try_from(dst).unwrap() > mem.current_length {
-        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
-    }
+    unsafe {
+        if usize::try_from(dst).unwrap() > mem.current_length {
+            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+        }
 
-    let dst = isize::try_from(dst).unwrap();
-    if dst & 0b11 != 0 {
-        return Err(Trap::lib(TrapCode::UnalignedAtomic));
-    }
+        let dst = isize::try_from(dst).unwrap();
+        if dst & 0b11 != 0 {
+            return Err(Trap::lib(TrapCode::UnalignedAtomic));
+        }
 
-    // Bounds and casts are checked above, by this point we know that
-    // everything is safe.
-    let dst = mem.base.offset(dst) as *mut u32;
-    let atomic_dst = AtomicPtr::new(dst);
-    let read_val = *atomic_dst.load(Ordering::Acquire);
-    let ret = if read_val == val { 0 } else { 1 };
-    Ok(ret)
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        let dst = mem.base.offset(dst) as *mut u32;
+        let atomic_dst = AtomicPtr::new(dst);
+        let read_val = *atomic_dst.load(Ordering::Acquire);
+        let ret = if read_val == val { 0 } else { 1 };
+        Ok(ret)
+    }
 }
 
 /// Perform the `memory32.atomic.check64` operation for the memory. Return 0 if same, 1 if different
@@ -422,22 +428,24 @@ pub(crate) unsafe fn memory32_atomic_check64(
     dst: u32,
     val: u64,
 ) -> Result<u32, Trap> {
-    if usize::try_from(dst).unwrap() > mem.current_length {
-        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
-    }
+    unsafe {
+        if usize::try_from(dst).unwrap() > mem.current_length {
+            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+        }
 
-    let dst = isize::try_from(dst).unwrap();
-    if dst & 0b111 != 0 {
-        return Err(Trap::lib(TrapCode::UnalignedAtomic));
-    }
+        let dst = isize::try_from(dst).unwrap();
+        if dst & 0b111 != 0 {
+            return Err(Trap::lib(TrapCode::UnalignedAtomic));
+        }
 
-    // Bounds and casts are checked above, by this point we know that
-    // everything is safe.
-    let dst = mem.base.offset(dst) as *mut u64;
-    let atomic_dst = AtomicPtr::new(dst);
-    let read_val = *atomic_dst.load(Ordering::Acquire);
-    let ret = if read_val == val { 0 } else { 1 };
-    Ok(ret)
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        let dst = mem.base.offset(dst) as *mut u64;
+        let atomic_dst = AtomicPtr::new(dst);
+        let read_val = *atomic_dst.load(Ordering::Acquire);
+        let ret = if read_val == val { 0 } else { 1 };
+        Ok(ret)
+    }
 }
 
 /// The fields compiled code needs to access to utilize a WebAssembly table
@@ -535,9 +543,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);
 
@@ -582,7 +609,7 @@ impl Default for VMSharedSignatureIndex {
 /// The VM caller-checked "anyfunc" record, for caller-side signature checking.
 /// It consists of the actual function pointer and a signature id to be checked
 /// by the caller.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy)]
 #[repr(C)]
 pub struct VMCallerCheckedAnyfunc {
     /// Function body.
@@ -597,6 +624,26 @@ pub struct VMCallerCheckedAnyfunc {
     // If more elements are added here, remember to add offset_of tests below!
 }
 
+impl PartialEq for VMCallerCheckedAnyfunc {
+    fn eq(&self, other: &Self) -> bool {
+        self.func_ptr == other.func_ptr
+            && self.type_index == other.type_index
+            && self.vmctx == other.vmctx
+            && ptr::fn_addr_eq(self.call_trampoline, other.call_trampoline)
+    }
+}
+
+impl Eq for VMCallerCheckedAnyfunc {}
+
+impl Hash for VMCallerCheckedAnyfunc {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.func_ptr.hash(state);
+        self.type_index.hash(state);
+        self.vmctx.hash(state);
+        ptr::hash(self.call_trampoline as *const (), state);
+    }
+}
+
 #[cfg(test)]
 mod test_vmcaller_checked_anyfunc {
     use super::VMCallerCheckedAnyfunc;
@@ -645,71 +692,80 @@ impl VMBuiltinFunctionsArray {
 
         let mut ptrs = [0; Self::len()];
 
-        ptrs[VMBuiltinFunctionIndex::get_memory32_grow_index().index() as usize] =
-            wasmer_vm_memory32_grow as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_grow_index().index() as usize] =
-            wasmer_vm_imported_memory32_grow as usize;
-
-        ptrs[VMBuiltinFunctionIndex::get_memory32_size_index().index() as usize] =
-            wasmer_vm_memory32_size as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_size_index().index() as usize] =
-            wasmer_vm_imported_memory32_size as usize;
-
-        ptrs[VMBuiltinFunctionIndex::get_table_copy_index().index() as usize] =
-            wasmer_vm_table_copy as usize;
-
-        ptrs[VMBuiltinFunctionIndex::get_table_init_index().index() as usize] =
-            wasmer_vm_table_init as usize;
-        ptrs[VMBuiltinFunctionIndex::get_elem_drop_index().index() as usize] =
-            wasmer_vm_elem_drop as usize;
-
-        ptrs[VMBuiltinFunctionIndex::get_memory_copy_index().index() as usize] =
-            wasmer_vm_memory32_copy as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_memory_copy_index().index() as usize] =
-            wasmer_vm_imported_memory32_copy as usize;
-        ptrs[VMBuiltinFunctionIndex::get_memory_fill_index().index() as usize] =
-            wasmer_vm_memory32_fill as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_memory_fill_index().index() as usize] =
-            wasmer_vm_imported_memory32_fill as usize;
-        ptrs[VMBuiltinFunctionIndex::get_memory_init_index().index() as usize] =
-            wasmer_vm_memory32_init as usize;
-        ptrs[VMBuiltinFunctionIndex::get_data_drop_index().index() as usize] =
-            wasmer_vm_data_drop as usize;
-        ptrs[VMBuiltinFunctionIndex::get_raise_trap_index().index() as usize] =
-            wasmer_vm_raise_trap as usize;
-        ptrs[VMBuiltinFunctionIndex::get_table_size_index().index() as usize] =
-            wasmer_vm_table_size as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_table_size_index().index() as usize] =
-            wasmer_vm_imported_table_size as usize;
-        ptrs[VMBuiltinFunctionIndex::get_table_grow_index().index() as usize] =
-            wasmer_vm_table_grow as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_table_grow_index().index() as usize] =
-            wasmer_vm_imported_table_grow as usize;
-        ptrs[VMBuiltinFunctionIndex::get_table_get_index().index() as usize] =
-            wasmer_vm_table_get as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_table_get_index().index() as usize] =
-            wasmer_vm_imported_table_get as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory32_grow_index().index() as *const () as usize] =
+            wasmer_vm_memory32_grow as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_grow_index().index() as *const ()
+            as usize] = wasmer_vm_imported_memory32_grow as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory32_size_index().index() as *const () as usize] =
+            wasmer_vm_memory32_size as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_size_index().index() as *const ()
+            as usize] = wasmer_vm_imported_memory32_size as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_copy_index().index() as *const () as usize] =
+            wasmer_vm_table_copy as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_init_index().index() as *const () as usize] =
+            wasmer_vm_table_init as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_elem_drop_index().index() as *const () as usize] =
+            wasmer_vm_elem_drop as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_copy_index().index() as *const () as usize] =
+            wasmer_vm_memory32_copy as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_copy_index().index() as *const ()
+            as usize] = wasmer_vm_imported_memory32_copy as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_fill_index().index() as *const () as usize] =
+            wasmer_vm_memory32_fill as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_fill_index().index() as *const ()
+            as usize] = wasmer_vm_imported_memory32_fill as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_init_index().index() as *const () as usize] =
+            wasmer_vm_memory32_init as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_data_drop_index().index() as *const () as usize] =
+            wasmer_vm_data_drop as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_raise_trap_index().index() as *const () as usize] =
+            wasmer_vm_raise_trap as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_size_index().index() as *const () as usize] =
+            wasmer_vm_table_size as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_size_index().index() as *const ()
+            as usize] = wasmer_vm_imported_table_size as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_grow_index().index() as *const () as usize] =
+            wasmer_vm_table_grow as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_grow_index().index() as *const ()
+            as usize] = wasmer_vm_imported_table_grow as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_get_index().index() as *const () as usize] =
+            wasmer_vm_table_get as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_get_index().index() as *const ()
+            as usize] = wasmer_vm_imported_table_get as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_table_set_index().index() as usize] =
-            wasmer_vm_table_set as usize;
+            wasmer_vm_table_set as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_table_set_index().index() as usize] =
-            wasmer_vm_imported_table_set as usize;
+            wasmer_vm_imported_table_set as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_func_ref_index().index() as usize] =
-            wasmer_vm_func_ref as usize;
+            wasmer_vm_func_ref as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_table_fill_index().index() as usize] =
-            wasmer_vm_table_fill as usize;
-
+            wasmer_vm_table_fill as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait32_index().index() as usize] =
-            wasmer_vm_memory32_atomic_wait32 as usize;
+            wasmer_vm_memory32_atomic_wait32 as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index().index() as usize] =
-            wasmer_vm_imported_memory32_atomic_wait32 as usize;
+            wasmer_vm_imported_memory32_atomic_wait32 as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait64_index().index() as usize] =
-            wasmer_vm_memory32_atomic_wait64 as usize;
+            wasmer_vm_memory32_atomic_wait64 as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index().index() as usize] =
-            wasmer_vm_imported_memory32_atomic_wait64 as usize;
+            wasmer_vm_imported_memory32_atomic_wait64 as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_memory_atomic_notify_index().index() as usize] =
-            wasmer_vm_memory32_atomic_notify as usize;
+            wasmer_vm_memory32_atomic_notify as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index().index() as usize] =
-            wasmer_vm_imported_memory32_atomic_notify as usize;
+            wasmer_vm_imported_memory32_atomic_notify as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_debug_usize_index().index() as usize] =
+            wasmer_vm_dbg_usize as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_debug_str_index().index() as usize] =
+            wasmer_vm_dbg_str as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_personality2_index().index() as usize] =
+            wasmer_eh_personality2 as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_alloc_exception_index().index() as usize] =
+            wasmer_vm_alloc_exception as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_throw_index().index() as usize] =
+            wasmer_vm_throw as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_read_exnref_index().index() as usize] =
+            wasmer_vm_read_exnref as *const () as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_exception_into_exnref_index().index() as usize] =
+            wasmer_vm_exception_into_exnref as *const () as usize;
 
         debug_assert!(ptrs.iter().cloned().all(|p| p != 0));
 
@@ -739,16 +795,22 @@ impl VMContext {
     #[allow(clippy::cast_ptr_alignment)]
     #[inline]
     pub(crate) unsafe fn instance(&self) -> &Instance {
-        &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *const Instance)
+        unsafe {
+            &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset())
+                as *const Instance)
+        }
     }
 
     #[inline]
     pub(crate) unsafe fn instance_mut(&mut self) -> &mut Instance {
-        &mut *((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *mut Instance)
+        unsafe {
+            &mut *((self as *const Self as *mut u8).offset(-Instance::vmctx_offset())
+                as *mut Instance)
+        }
     }
 }
 
-///
+/// 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..7a5100ded6 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.700.0"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
 readme = "README.md"
@@ -13,20 +13,20 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-anyhow = "1.0"
-async-trait = { version = "0.1.50", optional = true }
-bitflags = "1.2"
-once_cell = "1.13"
-thiserror = "1.0"
-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 }
+anyhow.workspace = true
+async-trait = { workspace = true, optional = true }
+bitflags.workspace = true
+once_cell.workspace = true
+thiserror.workspace = true
+tracing = { workspace = true, optional = true }
+wai-bindgen-wasmer-impl.workspace = true
+wasmer = { version = "=7.0.0", path = "../api", default-features = false }
 
 [features]
 # Enables generated code to emit events via the `tracing` crate whenever wasm is
 # entered and when native functions are called. Note that tracing is currently
 # only done for imported functions.
-tracing = ["tracing-lib", "wai-bindgen-wasmer-impl/tracing"]
+tracing = ["dep:tracing", "wai-bindgen-wasmer-impl/tracing"]
 
 # Enables async support for generated code, although when enabled this still
 # needs to be configured through the macro invocation.
@@ -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/cranelift"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wai-bindgen-wasmer/src/le.rs b/lib/wai-bindgen-wasmer/src/le.rs
index f821a99fe1..f0bc94e51e 100644
--- a/lib/wai-bindgen-wasmer/src/le.rs
+++ b/lib/wai-bindgen-wasmer/src/le.rs
@@ -10,7 +10,7 @@ use std::slice;
 /// not guaranteed to be either aligned or in the native endianness. This type
 /// wraps these types and provides explicit getters/setters to interact with the
 /// underlying value in a safe host-agnostic manner.
-#[repr(packed)]
+#[repr(C, packed)]
 pub struct Le<T>(T);
 
 impl<T> Le<T>
@@ -53,7 +53,7 @@ where
         //   `AllBytesValid` supertrait of `Endian`.
         unsafe {
             assert_eq!(mem::align_of::<Le<T>>(), 1);
-            assert!(bytes.len() % mem::size_of::<Le<T>>() == 0);
+            assert!(bytes.len().is_multiple_of(mem::size_of::<Le<T>>()));
             fn all_bytes_valid<T: AllBytesValid>() {}
             all_bytes_valid::<Le<T>>();
 
@@ -71,7 +71,7 @@ where
         // maintain the guarantee of uniqueness.
         unsafe {
             assert_eq!(mem::align_of::<Le<T>>(), 1);
-            assert!(bytes.len() % mem::size_of::<Le<T>>() == 0);
+            assert!(bytes.len().is_multiple_of(mem::size_of::<Le<T>>()));
             slice::from_raw_parts_mut(
                 bytes.as_mut_ptr().cast::<Le<T>>(),
                 bytes.len() / mem::size_of::<Le<T>>(),
diff --git a/lib/wai-bindgen-wasmer/src/lib.rs b/lib/wai-bindgen-wasmer/src/lib.rs
index aadf7ff777..1c1bb901aa 100644
--- a/lib/wai-bindgen-wasmer/src/lib.rs
+++ b/lib/wai-bindgen-wasmer/src/lib.rs
@@ -1,10 +1,10 @@
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use wai_bindgen_wasmer_impl::{export, import};
 
 #[cfg(feature = "async")]
 pub use async_trait::async_trait;
-#[cfg(feature = "tracing-lib")]
+#[cfg(feature = "tracing")]
 pub use tracing_lib as tracing;
 #[doc(hidden)]
 pub use {anyhow, bitflags, once_cell, wasmer};
@@ -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..47d278597d 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.700.0"
 description = "WASI and WASIX types for Wasmer WebAssembly runtime"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
@@ -15,29 +15,31 @@ 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" }
-wai-bindgen-gen-rust = "0.2.1"
-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"
-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" }
+wasmer = { default-features = false, path = "../api", version = "=7.0.0" }
+wasmer-types = { path = "../types", version = "=7.0.0" }
+wasmer-derive = { path = "../derive", version = "=7.0.0" }
+wai-bindgen-gen-rust.workspace = true
+wai-bindgen-rust = { workspace = true, default-features = false, features = [
+	"macros",
+] }
+wai-bindgen-gen-rust-wasm.workspace = true
+wai-bindgen-gen-core.workspace = true
+wai-parser.workspace = true
+serde = { workspace = true, features = ["derive"], optional = true }
+num_enum.workspace = true
+bitflags.workspace = true
+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"
+[dev-dependencies]
+pretty_assertions.workspace = true
 
 [features]
 enable-serde = ["serde", "wasmer-types/serde"]
 
 [package.metadata.docs.rs]
-features = ["wasmer/sys"]
+features = ["wasmer/sys", "wasmer/cranelift"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wasi-types/src/lib.rs b/lib/wasi-types/src/lib.rs
index f1c745d1fe..12edd42154 100644
--- a/lib/wasi-types/src/lib.rs
+++ b/lib/wasi-types/src/lib.rs
@@ -1,6 +1,6 @@
 #![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))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod asyncify;
 pub mod types;
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..d658aeface 100644
--- a/lib/wasi-types/src/wasi/bindings.rs
+++ b/lib/wasi-types/src/wasi/bindings.rs
@@ -1,3 +1,6 @@
+// Important note: make sure all enums are marked #[non_exhaustive] to force
+// Rust code to handle invalid values passed in from guests.
+
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
@@ -36,6 +39,7 @@ pub type Pid = u32;
 #[repr(u32)]
 #[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Snapshot0Clockid {
     #[doc = " The clock measuring real time. Time value zero corresponds with"]
     #[doc = " 1970-01-01T00:00:00Z."]
@@ -70,6 +74,7 @@ impl core::fmt::Debug for Snapshot0Clockid {
 #[doc = " Identifiers for clocks."]
 #[repr(u32)]
 #[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+#[non_exhaustive]
 pub enum Clockid {
     #[doc = " The clock measuring real time. Time value zero corresponds with"]
     #[doc = " 1970-01-01T00:00:00Z."]
@@ -104,6 +109,7 @@ impl core::fmt::Debug for Clockid {
 #[repr(u16)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Errno {
     #[doc = " No error occurred. System call completed successfully."]
     Success,
@@ -556,6 +562,7 @@ impl Rights {
 #[doc = " The type of a file descriptor or file."]
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Filetype {
     #[doc = " The type of the file descriptor or file is unknown or is different from any of the other types specified."]
     Unknown,
@@ -644,6 +651,7 @@ impl core::fmt::Debug for Dirent {
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Advice {
     #[doc = " The application has no advice to give on its behavior with respect to the specified data."]
     Normal,
@@ -673,6 +681,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))]
@@ -791,6 +815,7 @@ pub type Userdata = u64;
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Eventtype {
     #[doc = " The time value of clock `subscription_clock::id` has"]
     #[doc = " reached timestamp `subscription_clock::timeout`."]
@@ -887,6 +912,7 @@ impl core::fmt::Debug for SubscriptionClock {
 #[doc = " Identifiers for preopened capabilities."]
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Preopentype {
     #[doc = " A pre-opened directory."]
     Dir,
@@ -959,6 +985,7 @@ impl core::fmt::Debug for SubscriptionFsReadwrite {
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Socktype {
     Unknown,
     Stream,
@@ -979,6 +1006,7 @@ impl core::fmt::Debug for Socktype {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Sockstatus {
     Opening,
     Opened,
@@ -1000,6 +1028,7 @@ impl core::fmt::Debug for Sockstatus {
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Sockoption {
     Noop,
     ReusePort,
@@ -1064,6 +1093,7 @@ impl core::fmt::Debug for Sockoption {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Streamsecurity {
     Unencrypted,
     AnyEncryption,
@@ -1091,6 +1121,7 @@ impl core::fmt::Debug for Streamsecurity {
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Addressfamily {
     Unspec,
     Inet4,
@@ -1161,6 +1192,7 @@ impl core::fmt::Debug for Filestat {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Snapshot0Whence {
     Cur,
     End,
@@ -1180,6 +1212,7 @@ impl core::fmt::Debug for Snapshot0Whence {
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum Whence {
     Set,
     Cur,
@@ -1229,6 +1262,7 @@ impl core::fmt::Debug for Tty {
 #[doc = " __wasi_option_t"]
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum OptionTag {
     None,
     Some,
@@ -1343,6 +1377,7 @@ impl core::fmt::Debug for PipeHandles {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum StdioMode {
     Piped,
     Inherit,
@@ -1362,6 +1397,7 @@ impl core::fmt::Debug for StdioMode {
 #[repr(u16)]
 #[derive(Clone, Copy, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
 pub enum SockProto {
     Ip,
     Icmp,
@@ -2204,6 +2240,7 @@ impl core::fmt::Debug for SockProto {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Bool {
     False,
     True,
@@ -2240,6 +2277,8 @@ 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))]
+#[non_exhaustive]
 pub enum Signal {
     Signone = 0,
     Sighup,
@@ -2273,6 +2312,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 +2349,198 @@ 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))]
+#[non_exhaustive]
+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)]
+#[non_exhaustive]
+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)]
+#[non_exhaustive]
+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 {
@@ -2390,6 +2619,7 @@ pub type SdFlags = u8;
 pub type SiFlags = u16;
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Timeout {
     Read,
     Write,
@@ -2427,6 +2657,7 @@ impl JoinFlags {
 #[doc = " What has happened with the proccess when we joined on it"]
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum JoinStatusType {
     #[doc = " Nothing has happened"]
     Nothing,
@@ -2739,6 +2970,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..56c2f574b5 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.700.0"
 description = "WASI and WASIX implementation library for Wasmer WebAssembly runtime"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
@@ -13,105 +13,128 @@ 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.700.0", features = [
+	"enable-serde",
+] }
+wasmer-types = { path = "../types", version = "=7.0.0", default-features = false }
+wasmer = { path = "../api", version = "=7.0.0", default-features = false, features = [
+	"experimental-async",
+] }
+virtual-mio = { path = "../virtual-io", version = "0.700.0", default-features = false }
+virtual-fs = { path = "../virtual-fs", version = "0.700.0", default-features = false, features = [
+	"webc-fs",
+] }
+virtual-net = { path = "../virtual-net", version = "0.700.0", default-features = false, features = [
+	"rkyv",
+] }
+wasmer-journal = { path = "../journal", version = "0.700.0", default-features = false }
+wasmer-config = { version = "0.700.0", path = "../config" }
 
 http.workspace = true
 dashmap.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"
-typetag = { version = "0.1", optional = true }
-serde = { version = "1.0", 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" }
-waker-fn = { version = "1.1" }
-cooked-waker = "^5"
+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 = { workspace = true, features = ["xxh64"] }
+rusty_pool = { workspace = true, optional = true }
+cfg-if.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+getrandom.workspace = true
+typetag = { workspace = true, optional = true }
+serde = { workspace = true, default-features = false, features = ["derive"] }
+bincode.workspace = true
+chrono = { workspace = true, default-features = false, features = [
+	"wasmbind",
+	"std",
+	"clock",
+], optional = true }
+bytes.workspace = true
+anyhow.workspace = true
+sha2.workspace = true
+waker-fn.workspace = true
+cooked-waker.workspace = true
+# TODO: port to newer version
 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" ] }
-futures = { version = "0.3" }
+tokio-stream = { workspace = true, features = ["sync"] }
+futures.workspace = true
 # used by feature='os'
-async-trait = { version = "^0.1" }
-urlencoding = { version = "^2" }
-serde_derive = { version = "^1" }
-serde_json = { version = "^1" }
-serde_yaml.workspace = true
-weezl = { version = "^0.1" }
-hex = { version = "^0.4" }
-linked_hash_set = { version = "0.1" }
-heapless = "0.7.16"
-once_cell = "1.17.0"
-pin-project = "1.0.12"
-semver = "1.0.17"
-tempfile = "3.6.0"
-num_enum = "0.5.7"
+async-trait.workspace = true
+urlencoding.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+weezl.workspace = true
+hex.workspace = true
+linked_hash_set.workspace = true
+heapless.workspace = true
+once_cell.workspace = true
+pin-project.workspace = true
+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 }
-tower-http = { version = "0.5.0", features = [
-    "trace",
-    "util",
-    "catch-panic",
-    "cors",
+wcgi = { workspace = true, optional = true }
+wcgi-host = { workspace = true, optional = true }
+tower-http = { workspace = true, features = [
+	"trace",
+	"util",
+	"catch-panic",
+	"cors",
+], optional = true }
+tower = { workspace = true, features = ["make", "util"], optional = true }
+url.workspace = true
+bytecheck.workspace = true
+blake3.workspace = true
+petgraph.workspace = true
+lz4_flex.workspace = true
+flate2.workspace = true
+rayon = { workspace = true, optional = true }
+wasm-bindgen = { workspace = true, optional = true }
+js-sys = { workspace = true, optional = true }
+wasm-bindgen-futures = { workspace = true, optional = true }
+web-sys = { workspace = true, features = [
+	"Request",
+	"RequestInit",
+	"Window",
+	"WorkerGlobalScope",
+	"RequestMode",
+	"Response",
+	"Headers",
 ], 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"
-lz4_flex = { version = "0.11" }
-rayon = { version = "1.7.0", 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",
+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"
-pin-utils = "0.1.0"
+http-body-util = { workspace = true, optional = true }
+toml.workspace = true
+pin-utils.workspace = true
+wasmparser.workspace = true
+crossbeam-channel.workspace = true
+bus.workspace = true
 
-[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"]
@@ -121,28 +144,46 @@ optional = true
 libc.workspace = true
 
 [target.'cfg(all(unix, not(target_os="ios")))'.dependencies]
-termios = { version = "0.3" }
+termios.workspace = true
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_System_SystemInformation"] }
+windows-sys = { workspace = true, features = [
+	"Win32_System_SystemInformation",
+] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-terminal_size = { version = "0.3.0" }
+terminal_size.workspace = true
+zstd.workspace = true
 
 [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"
-wasm-bindgen-test = "0.3.0"
+wasmer = { path = "../api", version = "=7.0.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.workspace = true
+env_logger = { workspace = true, default-features = false }
+log.workspace = true
+assert-panic.workspace = true
+ciborium.workspace = true
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-wasm-bindgen-test = "0.3.0"
-tracing-wasm = "0.2"
+wasm-bindgen-test.workspace = true
+tracing-wasm.workspace = true
 
 [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 = "=7.0.0", default-features = false, features = [
+	"wat",
+	"js-serializable-module",
+	"cranelift",
+] }
 
 [features]
 default = ["sys-default"]
@@ -150,24 +191,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 +237,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 +261,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/cranelift",
+	"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..008034016d 100644
--- a/lib/wasix/src/bin_factory/binary_package.rs
+++ b/lib/wasix/src/bin_factory/binary_package.rs
@@ -1,28 +1,32 @@
 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 virtual_fs::UnionFileSystem;
+use wasmer_config::package::{
+    PackageHash, PackageId, PackageSource, SuggestedCompilerOptimizations,
+};
+use wasmer_package::package::Package;
+use webc::Container;
+use webc::compat::SharedBytes;
 
 use crate::{
+    Runtime,
     runners::MappedDirectory,
     runtime::resolver::{PackageInfo, ResolveError},
-    Runtime,
 };
 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,36 @@ 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] {
+    /// Get a reference to this [`BinaryPackageCommand`]'s atom as a cheap
+    /// clone of the internal OwnedBuffer.
+    pub fn atom(&self) -> SharedBytes {
+        self.atom.clone()
+    }
+
+    /// Get a reference to this [`BinaryPackageCommand`]'s atom as a cheap
+    /// clone of the internal OwnedBuffer.
+    pub fn atom_ref(&self) -> &SharedBytes {
         &self.atom
     }
 
     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
@@ -74,7 +96,10 @@ pub struct BinaryPackage {
     /// entrypoint.
     pub entrypoint_cmd: Option<String>,
     pub hash: OnceCell<ModuleHash>,
-    pub webc_fs: Arc<dyn FileSystem + Send + Sync>,
+    // TODO: using a UnionFileSystem here directly is suboptimal, since cloning
+    // it is expensive. Should instead store an immutable map that can easily
+    // be converted into a dashmap.
+    pub webc_fs: Option<Arc<UnionFileSystem>>,
     pub commands: Vec<BinaryPackageCommand>,
     pub uses: Vec<String>,
     pub file_system_memory_footprint: u64,
@@ -96,7 +121,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 +230,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())
     }
 
@@ -220,21 +245,40 @@ impl BinaryPackage {
             if let Some(cmd) = self.get_entrypoint_command() {
                 cmd.hash
             } else {
-                ModuleHash::xxhash(self.id.to_string())
+                ModuleHash::new(self.id.to_string())
             }
         })
     }
+
+    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)]
 mod tests {
     use sha2::Digest;
     use tempfile::TempDir;
-    use virtual_fs::AsyncReadExt;
+    use virtual_fs::{AsyncReadExt, FileSystem as _};
+    use wasmer_package::utils::from_disk;
 
     use crate::{
-        runtime::{package_loader::BuiltinPackageLoader, task_manager::VirtualTaskManager},
         PluggableRuntime,
+        runtime::{package_loader::BuiltinPackageLoader, task_manager::VirtualTaskManager},
     };
 
     use super::*;
@@ -278,12 +322,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();
 
@@ -291,6 +335,8 @@ mod tests {
         // "/public/file.txt" on the guest.
         let mut f = pkg
             .webc_fs
+            .as_ref()
+            .expect("no webc fs")
             .new_open_options()
             .read(true)
             .open("/public/file.txt")
@@ -317,10 +363,10 @@ mod tests {
             name = "foo"
             source = "foo.wasm"
             abi = "wasi"
-            
+
             [[command]]
             name = "cmd"
-            module = "foo"     
+            module = "foo"
         "#;
         let manifest = temp.path().join("wasmer.toml");
         std::fs::write(&manifest, wasmer_toml).unwrap();
@@ -328,9 +374,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);
@@ -345,8 +389,8 @@ mod tests {
 
         assert_eq!(pkg.commands.len(), 1);
         let command = pkg.get_command("cmd").unwrap();
-        let atom_sha256_hash: [u8; 32] = sha2::Sha256::digest(webc.get_atom("foo").unwrap()).into();
-        let module_hash = ModuleHash::sha256_from_bytes(atom_sha256_hash);
+        let atom_sha256_hash = sha2::Sha256::digest(webc.get_atom("foo").unwrap()).into();
+        let module_hash = ModuleHash::from_bytes(atom_sha256_hash);
         assert_eq!(command.hash(), &module_hash);
     }
 }
diff --git a/lib/wasix/src/bin_factory/exec.rs b/lib/wasix/src/bin_factory/exec.rs
index 2dd675796f..78a6b59490 100644
--- a/lib/wasix/src/bin_factory/exec.rs
+++ b/lib/wasix/src/bin_factory/exec.rs
@@ -1,83 +1,96 @@
-use std::sync::Arc;
-
+#![allow(clippy::result_large_err)]
+use super::{BinaryPackage, BinaryPackageCommand};
 use crate::{
+    RewindState, SpawnError, WasiError, WasiRuntimeError,
     os::task::{
-        thread::{RewindResultType, WasiThreadRunGuard},
         TaskJoinHandle,
+        thread::{RewindResultType, WasiThreadRunGuard},
     },
     runtime::{
+        ModuleInput, TaintReason,
+        module_cache::HashedModuleData,
         task_manager::{
             TaskWasm, TaskWasmRecycle, TaskWasmRecycleProperties, TaskWasmRunProperties,
         },
-        TaintReason,
     },
+    state::context_switching::ContextSwitchingEnvironment,
     syscalls::rewind_ext,
-    RewindState, SpawnError, WasiError, WasiRuntimeError,
 };
+use crate::{Runtime, WasiEnv, WasiFunctionEnv};
+use std::{borrow::Cow, sync::Arc};
 use tracing::*;
-use wasmer::{Function, Memory32, Memory64, Module, Store};
+use virtual_mio::block_on;
+use wasmer::{Function, Memory32, Memory64, Module, RuntimeError, Store, Value};
 use wasmer_wasix_types::wasi::Errno;
 
-use super::BinaryPackage;
-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 input = ModuleInput::Command(Cow::Borrowed(cmd));
+    let module = runtime.resolve_module(input, None, None).await?;
+
+    // Free the space used by the binary, since we don't need it
+    // any longer
+    drop(binary);
 
-    spawn_exec_wasm(wasm, name, env, runtime).await
+    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 +98,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 +137,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))
             })?
     };
 
@@ -145,7 +165,7 @@ unsafe fn run_recycle(
 ) {
     if let Some(callback) = callback {
         let env = ctx.data_mut(&mut store);
-        let memory = env.memory().clone();
+        let memory = unsafe { env.memory() }.clone();
 
         let props = TaskWasmRecycleProperties {
             env: env.clone(),
@@ -165,25 +185,28 @@ pub fn run_exec(props: TaskWasmRunProperties) {
     let recycle = props.recycle;
 
     // Perform the initialization
-    let ctx = {
-        // If this module exports an _initialize function, run that first.
-        if let Ok(initialize) = unsafe { ctx.data(&store).inner() }
-            .instance
-            .exports
-            .get_function("_initialize")
-        {
-            let initialize = initialize.clone();
-            if let Err(err) = initialize.call(&mut store, &[]) {
-                thread.thread.set_status_finished(Err(err.into()));
-                ctx.data(&store)
-                    .blocking_on_exit(Some(Errno::Noexec.into()));
-                unsafe { run_recycle(recycle, ctx, store) };
-                return;
-            }
-        }
+    // If this module exports an _initialize function, run that first.
+    if let Ok(initialize) = ctx
+        .data(&store)
+        .inner()
+        .main_module_instance_handles()
+        .instance
+        .exports
+        .get_function("_initialize")
+        .cloned()
+    {
+        // This does not need a context switching environment as the documentation
+        // states that that is only available after the first call to main
+        let result = initialize.call(&mut store, &[]);
 
-        WasiFunctionEnv { env: ctx.env }
-    };
+        if let Err(err) = result {
+            thread.thread.set_status_finished(Err(err.into()));
+            ctx.data(&store)
+                .blocking_on_exit(Some(Errno::Noexec.into()));
+            unsafe { run_recycle(recycle, ctx, store) };
+            return;
+        }
+    }
 
     // Bootstrap the process
     // Unsafe: The bootstrap must be executed in the same thread that runs the
@@ -209,11 +232,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()
 }
 
@@ -264,66 +289,99 @@ 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 {
-            debug!("wasi[{}]::exec-failed: missing _start function", pid);
-            ctx.data(&store)
-                .blocking_on_exit(Some(Errno::Noexec.into()));
-            unsafe { run_recycle(recycle, ctx, store) };
-            return;
+    // Call the module
+    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()));
+        unsafe { run_recycle(recycle, ctx, store) };
+        return;
+    };
+
+    let (mut store, mut call_ret) =
+        ContextSwitchingEnvironment::run_main_context(&ctx, store, start.clone(), vec![]);
+
+    let mut store = loop {
+        // Technically, it's an error for a vfork to return from main, but anyway...
+        store = match resume_vfork(&ctx, store, &start, &call_ret) {
+            // A vfork was resumed, there may be another, so loop back
+            (store, Ok(Some(ret))) => {
+                call_ret = ret;
+                store
+            }
+
+            // An error was encountered when restoring from the vfork, report it
+            (store, Err(e)) => {
+                call_ret = Err(RuntimeError::user(Box::new(WasiError::Exit(e.into()))));
+                break store;
+            }
+
+            // No vfork, keep the call_ret value
+            (store, Ok(None)) => break store,
         };
+    };
 
-        if let Err(err) = call_ret {
-            match err.downcast::<WasiError>() {
-                Ok(WasiError::Exit(code)) if code.is_success() => Ok(Errno::Success),
-                Ok(WasiError::Exit(code)) => {
-                    runtime.on_taint(TaintReason::NonZeroExitCode(code));
-                    Err(WasiError::Exit(code).into())
-                }
-                Ok(WasiError::DeepSleep(deep)) => {
-                    // Create the callback that will be invoked when the thread respawns after a deep sleep
-                    let rewind = deep.rewind;
-                    let respawn = {
-                        move |ctx, store, rewind_result| {
-                            // Call the thread
-                            call_module(
-                                ctx,
-                                store,
-                                handle,
-                                Some((rewind, RewindResultType::RewindWithResult(rewind_result))),
-                                recycle,
-                            );
-                        }
-                    };
-
-                    // Spawns the WASM process after a trigger
-                    if let Err(err) = unsafe {
-                        tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
-                    } {
-                        debug!("failed to go into deep sleep - {}", err);
+    let ret = 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())
+            }
+            Ok(WasiError::DeepSleep(deep)) => {
+                // Create the callback that will be invoked when the thread respawns after a deep sleep
+                let rewind = deep.rewind;
+                let respawn = {
+                    move |ctx, store, rewind_result| {
+                        // Call the thread
+                        call_module(
+                            ctx,
+                            store,
+                            handle,
+                            Some((rewind, RewindResultType::RewindWithResult(rewind_result))),
+                            recycle,
+                        );
                     }
-                    return;
-                }
-                Ok(WasiError::UnknownWasiVersion) => {
-                    debug!("failed as wasi version is unknown",);
-                    runtime.on_taint(TaintReason::UnknownWasiVersion);
-                    Ok(Errno::Noexec)
-                }
-                Err(err) => {
-                    runtime.on_taint(TaintReason::RuntimeError(err.clone()));
-                    Err(WasiRuntimeError::from(err))
+                };
+
+                // Spawns the WASM process after a trigger
+                if let Err(err) = unsafe {
+                    tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
+                } {
+                    debug!("failed to go into deep sleep - {}", err);
                 }
+                return;
+            }
+            Ok(WasiError::UnknownWasiVersion) => {
+                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))
             }
-        } else {
-            Ok(Errno::Success)
         }
+    } else {
+        Ok(Errno::Success)
     };
 
     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 => {
+                let err_display = err.display(&mut store);
+                error!("{err_display}");
+                eprintln!("{err_display}");
+                Errno::Noexec.into()
+            }
+        }
     } else {
         Errno::Success.into()
     };
@@ -335,3 +393,129 @@ 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,
+    mut store: Store,
+    start: &Function,
+    call_ret: &Result<Box<[Value]>, RuntimeError>,
+) -> (
+    Store,
+    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 (store, 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(&mut store).vfork.take() {
+        if let Some(err) = err {
+            error!(%err, "Error from child process");
+            eprintln!("{err}");
+        }
+
+        block_on(
+            unsafe { ctx.data(&store).get_memory_and_wasi_state(&store, 0) }
+                .1
+                .fs
+                .close_all(),
+        );
+
+        tracing::debug!(
+            pid = %ctx.data_mut(&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(&mut store));
+        std::mem::swap(vfork.env.as_mut(), ctx.data_mut(&mut store));
+        let mut child_env = *vfork.env;
+        child_env.owned_handles.push(vfork.handle);
+
+        // Terminate the child process
+        child_env.process.terminate(code);
+
+        // If the vfork contained a context-switching environment, exit now
+        if ctx.data(&store).context_switching_environment.is_some() {
+            // We cannot recover from this situation when using context switching
+            tracing::error!(
+                "Terminated a vfork in another way than exit or exec which is undefined behaviour. In this case the parent process will be terminated."
+            );
+            return (store, Err(code.into()));
+        }
+        let Some(asyncify_info) = vfork.asyncify else {
+            // We can only recover from this situation when using asyncify-based vforking; since asyncify is not in use here, we cannot recover and must terminate the parent process
+            tracing::error!(
+                "Terminated a vfork in another way than exit or exec which is undefined behaviour. In this case the parent process will be terminated."
+            );
+            return (store, Err(code.into()));
+        };
+        // TODO: We can also only safely recover if we are not using nested calling
+        // TODO: Just delete this branch
+
+        // Jump back to the vfork point and continue execution
+        let child_pid = child_env.process.pid();
+        let rewind_stack = asyncify_info.rewind_stack.freeze();
+        let store_data = asyncify_info.store_data;
+
+        let ctx_cloned = ctx.env.clone().into_mut(&mut store);
+        // Now rewind the previous stack and carry on from where we did the vfork
+        let rewind_result = if asyncify_info.is_64bit {
+            crate::syscalls::rewind::<Memory64, _>(
+                ctx_cloned,
+                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_cloned,
+                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 => {
+                // We should only get here, if the engine does not support context switching
+                // If the engine supports it, we should exit in the check a few lines above
+                let (store, result) = ContextSwitchingEnvironment::run_main_context(
+                    ctx,
+                    store,
+                    start.clone(),
+                    vec![],
+                );
+                (store, Ok(Some(result)))
+            }
+            err => {
+                warn!("fork failed - could not rewind the stack - errno={}", err);
+                (store, Err(err))
+            }
+        }
+    } else {
+        (store, Ok(None))
+    }
+}
diff --git a/lib/wasix/src/bin_factory/mod.rs b/lib/wasix/src/bin_factory/mod.rs
index 0cb8cee8e0..5dfd00cc0f 100644
--- a/lib/wasix/src/bin_factory/mod.rs
+++ b/lib/wasix/src/bin_factory/mod.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::result_large_err)]
 use std::{
     collections::HashMap,
     future::Future,
@@ -8,11 +9,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,19 +20,21 @@ 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, SpawnError, WasiEnv,
+    os::{command::Commands, task::TaskJoinHandle},
+    runtime::module_cache::HashedModuleData,
 };
 
 #[derive(Debug, Clone)]
 pub struct BinFactory {
     pub(crate) commands: Commands,
     runtime: Arc<dyn Runtime + Send + Sync + 'static>,
-    pub(crate) local: Arc<RwLock<HashMap<String, Option<BinaryPackage>>>>,
+    pub(crate) local: Arc<RwLock<HashMap<String, Option<Arc<BinaryPackage>>>>>,
 }
 
 impl BinFactory {
@@ -48,9 +50,9 @@ impl BinFactory {
         self.runtime.deref()
     }
 
-    pub fn set_binary(&self, name: &str, binary: BinaryPackage) {
+    pub fn set_binary(&self, name: &str, binary: &Arc<BinaryPackage>) {
         let mut cache = self.local.write().unwrap();
-        cache.insert(name.to_string(), Some(binary));
+        cache.insert(name.to_string(), Some(binary.clone()));
     }
 
     #[allow(clippy::await_holding_lock)]
@@ -58,7 +60,7 @@ impl BinFactory {
         &self,
         name: &str,
         fs: Option<&dyn FileSystem>,
-    ) -> Option<BinaryPackage> {
+    ) -> Option<Arc<BinaryPackage>> {
         self.get_executable(name, fs)
             .await
             .and_then(|executable| match executable {
@@ -70,7 +72,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 +82,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
+                    {
+                        let cmd = package_command_by_name(&pkg, name.as_str())?;
+                        env.prepare_spawn(cmd);
+                    }
+
+                    spawn_exec(pkg.as_ref().clone(), name.as_str(), env, &self.runtime).await
                 }
             }
         })
@@ -102,15 +106,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);
@@ -128,7 +129,7 @@ impl BinFactory {
     ) -> Option<Executable> {
         let name = name.to_string();
 
-        // Fast path
+        // Return early if the path is already cached
         {
             let cache = self.local.read().unwrap();
             if let Some(data) = cache.get(&name) {
@@ -136,32 +137,31 @@ impl BinFactory {
             }
         }
 
-        // Slow path
         let mut cache = self.local.write().unwrap();
 
-        // Check the cache
+        // Check the cache again to avoid a race condition where the cache was populated inbetween the fast path and here
         if let Some(data) = cache.get(&name) {
             return data.clone().map(Executable::BinaryPackage);
         }
 
         // Check the filesystem for the file
-        if name.starts_with('/') {
-            if let Some(fs) = fs {
-                match load_executable_from_filesystem(fs, name.as_ref(), self.runtime()).await {
-                    Ok(executable) => {
-                        if let Executable::BinaryPackage(pkg) = &executable {
-                            cache.insert(name, Some(pkg.clone()));
-                        }
-
-                        return Some(executable);
-                    }
-                    Err(e) => {
-                        tracing::warn!(
-                            path = name,
-                            error = &*e,
-                            "Unable to load the package from disk"
-                        );
+        if name.starts_with('/')
+            && let Some(fs) = fs
+        {
+            match load_executable_from_filesystem(fs, name.as_ref(), self.runtime()).await {
+                Ok(executable) => {
+                    if let Executable::BinaryPackage(pkg) = &executable {
+                        cache.insert(name, Some(pkg.clone()));
                     }
+
+                    return Some(executable);
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        path = name,
+                        error = &*e,
+                        "Unable to load the package from disk"
+                    );
                 }
             }
         }
@@ -173,8 +173,8 @@ impl BinFactory {
 }
 
 pub enum Executable {
-    Wasm(bytes::Bytes),
-    BinaryPackage(BinaryPackage),
+    Wasm(OwnedBuffer),
+    BinaryPackage(Arc<BinaryPackage>),
 }
 
 async fn load_executable_from_filesystem(
@@ -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(Arc::new(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(Arc::new(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..520220b9d9 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,
+    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard, atomic::AtomicU64},
 };
 
-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 tokio::sync::{Mutex as AsyncMutex, watch};
+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,16 +69,16 @@ 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>,
 }
 
 impl InodeVal {
-    pub fn read(&self) -> RwLockReadGuard<Kind> {
+    pub fn read(&self) -> RwLockReadGuard<'_, Kind> {
         self.kind.read().unwrap()
     }
 
-    pub fn write(&self) -> RwLockWriteGuard<Kind> {
+    pub fn write(&self) -> RwLockWriteGuard<'_, Kind> {
         self.kind.write().unwrap()
     }
 }
@@ -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..3540a55834
--- /dev/null
+++ b/lib/wasix/src/fs/fd_list.rs
@@ -0,0 +1,705 @@
+//! 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::{
+            Arc, RwLock,
+            atomic::{AtomicI32, AtomicU64},
+        },
+    };
+
+    use assert_panic::assert_panic;
+    use wasmer_wasix_types::wasi::{Fdflags, Fdflagsext, Rights};
+
+    use crate::fs::{Inode, InodeGuard, InodeVal, Kind, fd::FdInner};
+
+    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..61ec5f6f66 100644
--- a/lib/wasix/src/fs/inode_guard.rs
+++ b/lib/wasix/src/fs/inode_guard.rs
@@ -8,18 +8,18 @@ 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},
     wasi::{Errno, EventFdReadwrite, Eventrwflags, Subscription},
 };
 
-use super::{notification::NotificationInner, InodeGuard, Kind};
+use super::{InodeGuard, Kind, notification::NotificationInner};
 use crate::{
     net::socket::{InodeSocketInner, InodeSocketKind},
-    state::{iterate_poll_events, PollEvent, PollEventSet, WasiState},
-    syscalls::{map_io_err, EventResult, EventResultType},
+    state::{PollEvent, PollEventSet, WasiState, iterate_poll_events},
+    syscalls::{EventResult, EventResultType, map_io_err},
     utils::{OwnedRwLockReadGuard, OwnedRwLockWriteGuard},
 };
 
@@ -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()))),
             },
             _ => {
@@ -83,11 +91,11 @@ impl std::fmt::Debug for InodeValFilePollGuard {
             }
             InodeValFilePollGuardMode::Socket { inner } => {
                 let inner = inner.protected.read().unwrap();
-                match inner.kind {
+                match &inner.kind {
                     InodeSocketKind::TcpListener { .. } => {
                         write!(f, "guard-tcp-listener(fd={}, peb={})", self.fd, self.peb)
                     }
-                    InodeSocketKind::TcpStream { ref socket, .. } => {
+                    InodeSocketKind::TcpStream { socket, .. } => {
                         if socket.is_closed() {
                             write!(
                                 f,
@@ -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;
@@ -196,11 +194,20 @@ impl Future for InodeValFilePollGuardJoin {
                     file.poll_read_ready(cx)
                 }
                 InodeValFilePollGuardMode::EventNotifications(inner) => inner.poll(waker).map(Ok),
-                InodeValFilePollGuardMode::Socket { ref inner } => {
+                InodeValFilePollGuardMode::Socket { inner } => {
                     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)
@@ -220,7 +227,7 @@ impl Future for InodeValFilePollGuardJoin {
                             }))
                         }
                         Eventtype::Clock => Some(EventResultType::Clock(0)),
-                        Eventtype::Unknown => None,
+                        _ => None,
                     };
                     if let Some(inner) = inner {
                         ret.push((
@@ -256,7 +263,7 @@ impl Future for InodeValFilePollGuardJoin {
                             }))
                         }
                         Eventtype::Clock => Some(EventResultType::Clock(0)),
-                        Eventtype::Unknown => None,
+                        _ => None,
                     };
                     if let Some(inner) = inner {
                         ret.push((
@@ -286,11 +293,20 @@ impl Future for InodeValFilePollGuardJoin {
                     file.poll_write_ready(cx)
                 }
                 InodeValFilePollGuardMode::EventNotifications(inner) => inner.poll(waker).map(Ok),
-                InodeValFilePollGuardMode::Socket { ref inner } => {
+                InodeValFilePollGuardMode::Socket { inner } => {
                     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)
@@ -310,7 +326,7 @@ impl Future for InodeValFilePollGuardJoin {
                             }))
                         }
                         Eventtype::Clock => Some(EventResultType::Clock(0)),
-                        Eventtype::Unknown => None,
+                        _ => None,
                     };
                     if let Some(inner) = inner {
                         ret.push((
@@ -346,7 +362,7 @@ impl Future for InodeValFilePollGuardJoin {
                             }))
                         }
                         Eventtype::Clock => Some(EventResultType::Clock(0)),
-                        Eventtype::Unknown => None,
+                        _ => None,
                     };
                     if let Some(inner) = inner {
                         ret.push((
@@ -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..ff6a3ec268 100644
--- a/lib/wasix/src/fs/mod.rs
+++ b/lib/wasix/src/fs/mod.rs
@@ -1,49 +1,61 @@
+// 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;
+pub(crate) mod relative_path_hack;
 
 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},
         Arc, Mutex, RwLock, Weak,
+        atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering},
     },
     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};
+use futures::{Future, TryStreamExt, future::BoxFuture};
 #[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 virtual_fs::{
+    FileSystem, FsError, OpenOptions, UnionFileSystem, VirtualFile, copy_reference,
+    tmp_fs::TmpFileSystem,
+};
 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,
+    InodeValFileReadGuard, InodeValFileWriteGuard, POLL_GUARD_MAX_RET, WasiStateFileGuard,
 };
 pub use self::notification::NotificationInner;
+use self::relative_path_hack::RelativeOrAbsolutePathHack;
 use crate::syscalls::map_io_err;
-use crate::{bin_factory::BinaryPackage, state::PreopenedDir, ALL_RIGHTS};
+use crate::{ALL_RIGHTS, bin_factory::BinaryPackage, state::PreopenedDir};
 
 /// the fd value of the virtual root
 ///
@@ -76,6 +88,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 +101,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 +112,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 +129,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 +219,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 +232,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 +276,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 +337,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),
@@ -291,91 +367,105 @@ impl Default for WasiInodes {
 
 #[derive(Debug, Clone)]
 pub enum WasiFsRoot {
-    Sandbox(Arc<virtual_fs::tmp_fs::TmpFileSystem>),
-    Backing(Arc<Box<dyn FileSystem>>),
-}
-
-impl WasiFsRoot {
-    /// Merge the contents of a filesystem into this one.
-    #[tracing::instrument(level = "debug", skip_all)]
-    pub(crate) async fn merge(
-        &self,
-        other: &Arc<dyn FileSystem + Send + Sync>,
-    ) -> Result<(), virtual_fs::FsError> {
-        match self {
-            WasiFsRoot::Sandbox(fs) => {
-                fs.union(other);
-                Ok(())
-            }
-            WasiFsRoot::Backing(fs) => {
-                merge_filesystems(other, fs).await?;
-                Ok(())
-            }
-        }
-    }
+    Sandbox(TmpFileSystem),
+    /// Dedicated canonical overlay representation.
+    ///
+    /// Overlays are the common form of the file system for WASIX packages.
+    /// Dependencies are all added to the overlay, with the regular file system
+    /// as the foundation.
+    ///
+    /// This dedicated variant is necessary to norm the behaviour and prevent
+    /// redundant recursive merging of filesystems when additional dependencies
+    /// are added.
+    Overlay(
+        Arc<
+            virtual_fs::OverlayFileSystem<
+                TmpFileSystem,
+                [RelativeOrAbsolutePathHack<UnionFileSystem>; 1],
+            >,
+        >,
+    ),
+    Backing(Arc<dyn FileSystem + Send + Sync>),
 }
 
 impl FileSystem for WasiFsRoot {
     fn readlink(&self, path: &Path) -> virtual_fs::Result<PathBuf> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.readlink(path),
-            WasiFsRoot::Backing(fs) => fs.readlink(path),
+            Self::Sandbox(fs) => fs.readlink(path),
+            Self::Overlay(overlay) => overlay.readlink(path),
+            Self::Backing(fs) => fs.readlink(path),
         }
     }
 
     fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.read_dir(path),
-            WasiFsRoot::Backing(fs) => fs.read_dir(path),
+            Self::Sandbox(fs) => fs.read_dir(path),
+            Self::Overlay(overlay) => overlay.read_dir(path),
+            Self::Backing(fs) => fs.read_dir(path),
         }
     }
+
     fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.create_dir(path),
-            WasiFsRoot::Backing(fs) => fs.create_dir(path),
+            Self::Sandbox(fs) => fs.create_dir(path),
+            Self::Overlay(overlay) => overlay.create_dir(path),
+            Self::Backing(fs) => fs.create_dir(path),
         }
     }
+
     fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.remove_dir(path),
-            WasiFsRoot::Backing(fs) => fs.remove_dir(path),
+            Self::Sandbox(fs) => fs.remove_dir(path),
+            Self::Overlay(overlay) => overlay.remove_dir(path),
+            Self::Backing(fs) => fs.remove_dir(path),
         }
     }
+
     fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
         let from = from.to_owned();
         let to = to.to_owned();
         let this = self.clone();
         Box::pin(async move {
             match this {
-                WasiFsRoot::Sandbox(fs) => fs.rename(&from, &to).await,
-                WasiFsRoot::Backing(fs) => fs.rename(&from, &to).await,
+                Self::Sandbox(fs) => fs.rename(&from, &to).await,
+                Self::Overlay(overlay) => overlay.rename(&from, &to).await,
+                Self::Backing(fs) => fs.rename(&from, &to).await,
             }
         })
     }
+
     fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.metadata(path),
-            WasiFsRoot::Backing(fs) => fs.metadata(path),
+            Self::Sandbox(fs) => fs.metadata(path),
+            Self::Overlay(overlay) => overlay.metadata(path),
+            Self::Backing(fs) => fs.metadata(path),
         }
     }
+
     fn symlink_metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.symlink_metadata(path),
-            WasiFsRoot::Backing(fs) => fs.symlink_metadata(path),
+            Self::Sandbox(fs) => fs.symlink_metadata(path),
+            Self::Overlay(overlay) => overlay.symlink_metadata(path),
+            Self::Backing(fs) => fs.symlink_metadata(path),
         }
     }
+
     fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.remove_file(path),
-            WasiFsRoot::Backing(fs) => fs.remove_file(path),
+            Self::Sandbox(fs) => fs.remove_file(path),
+            Self::Overlay(overlay) => overlay.remove_file(path),
+            Self::Backing(fs) => fs.remove_file(path),
         }
     }
-    fn new_open_options(&self) -> OpenOptions {
+
+    fn new_open_options(&self) -> OpenOptions<'_> {
         match self {
-            WasiFsRoot::Sandbox(fs) => fs.new_open_options(),
-            WasiFsRoot::Backing(fs) => fs.new_open_options(),
+            Self::Sandbox(fs) => fs.new_open_options(),
+            Self::Overlay(overlay) => overlay.new_open_options(),
+            Self::Backing(fs) => fs.new_open_options(),
         }
     }
+
     fn mount(
         &self,
         name: String,
@@ -383,20 +473,25 @@ impl FileSystem for WasiFsRoot {
         fs: Box<dyn FileSystem + Send + Sync>,
     ) -> virtual_fs::Result<()> {
         match self {
-            WasiFsRoot::Sandbox(f) => f.mount(name, path, fs),
-            WasiFsRoot::Backing(f) => f.mount(name, path, fs),
+            Self::Sandbox(root) => FileSystem::mount(root, name, path, fs),
+            Self::Overlay(overlay) => FileSystem::mount(overlay.primary(), name, path, fs),
+            Self::Backing(f) => f.mount(name, path, fs),
         }
     }
 }
 
 /// Merge the contents of one filesystem into another.
 ///
+/// NOTE: merging is a very expensive operation, since it requires copying
+/// many files in memory, even if the underlying files are immutable and
+/// mapped through mmap or similar mechanisms.
+/// Merging should be avoided when possible.
 #[tracing::instrument(level = "trace", skip_all)]
 async fn merge_filesystems(
     source: &dyn FileSystem,
     destination: &dyn FileSystem,
 ) -> Result<(), virtual_fs::FsError> {
-    tracing::debug!("Falling back to a recursive copy to merge filesystems");
+    tracing::warn!("Falling back to a recursive copy to merge filesystems");
     let files = futures::stream::FuturesUnordered::new();
 
     let mut to_check = VecDeque::new();
@@ -450,81 +545,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 +583,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()
             }
@@ -619,15 +662,28 @@ impl WasiFs {
         &self,
         binary: &BinaryPackage,
     ) -> Result<(), virtual_fs::FsError> {
-        let needs_to_be_unioned = self.has_unioned.lock().unwrap().insert(binary.id.clone());
+        let Some(webc_fs) = &binary.webc_fs else {
+            return Ok(());
+        };
 
+        let needs_to_be_unioned = self.has_unioned.lock().unwrap().insert(binary.id.clone());
         if !needs_to_be_unioned {
             return Ok(());
         }
 
-        self.root_fs.merge(&binary.webc_fs).await?;
-
-        Ok(())
+        match &self.root_fs {
+            WasiFsRoot::Sandbox(fs) => {
+                // TODO: this can be changed to switch to Self::Overlay instead!
+                let fdyn: Arc<dyn FileSystem + Send + Sync> = webc_fs.clone();
+                fs.union(&fdyn);
+                Ok(())
+            }
+            WasiFsRoot::Overlay(overlay) => {
+                let union = &overlay.secondaries()[0];
+                union.0.merge(webc_fs, virtual_fs::UnionMergeMode::Skip)
+            }
+            WasiFsRoot::Backing(backing) => merge_filesystems(webc_fs, backing).await,
+        }
     }
 
     /// Created for the builder API. like `new` but with more information
@@ -645,15 +701,13 @@ 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("./") {
-            let current_dir = self.current_dir.lock().unwrap();
-            path = format!("{}{}", current_dir.as_str(), &path[1..]);
-            if path.contains("//") {
-                path = path.replace("//", "/");
-            }
+    pub(crate) fn relative_path_to_absolute(&self, path: String) -> String {
+        if path.starts_with('/') {
+            return path;
         }
-        path
+
+        let current_dir = self.current_dir.lock().unwrap();
+        format!("{}/{}", current_dir.trim_end_matches('/'), path)
     }
 
     /// Private helper function to init the filesystem, called in `new` and
@@ -676,20 +730,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 +763,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 +772,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
@@ -730,7 +784,7 @@ impl WasiFs {
             let segment_name = c.as_os_str().to_string_lossy().to_string();
             let guard = cur_inode.read();
             match guard.deref() {
-                Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => {
+                Kind::Dir { entries, .. } | Kind::Root { entries } => {
                     if let Some(_entry) = entries.get(&segment_name) {
                         // TODO: this should be fixed
                         return Err(FsError::AlreadyExists);
@@ -754,10 +808,7 @@ impl WasiFs {
                     {
                         let mut guard = cur_inode.write();
                         match guard.deref_mut() {
-                            Kind::Dir {
-                                ref mut entries, ..
-                            }
-                            | Kind::Root { ref mut entries } => {
+                            Kind::Dir { entries, .. } | Kind::Root { entries } => {
                                 entries.insert(segment_name, inode.clone());
                             }
                             _ => unreachable!("Dir or Root became not Dir or Root"),
@@ -774,6 +825,7 @@ impl WasiFs {
             rights,
             rights_inheriting,
             flags,
+            fd_flags,
             Fd::READ | Fd::WRITE,
             cur_inode,
         )
@@ -783,6 +835,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 +847,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
@@ -801,7 +855,7 @@ impl WasiFs {
 
         let guard = base_inode.read();
         match guard.deref() {
-            Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => {
+            Kind::Dir { entries, .. } | Kind::Root { entries } => {
                 if let Some(_entry) = entries.get(&name) {
                     // TODO: eventually change the logic here to allow overwrites
                     return Err(FsError::AlreadyExists);
@@ -810,7 +864,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);
@@ -821,18 +875,36 @@ impl WasiFs {
                 {
                     let mut guard = base_inode.write();
                     match guard.deref_mut() {
-                        Kind::Dir {
-                            ref mut entries, ..
-                        }
-                        | Kind::Root { ref mut entries } => {
+                        Kind::Dir { entries, .. } | Kind::Root { entries } => {
                             entries.insert(name, inode.clone());
                         }
                         _ => unreachable!("Dir or Root became not Dir or Root"),
                     }
                 }
 
-                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();
+                    match guard.deref_mut() {
+                        Kind::File { fd, .. } => {
+                            *fd = Some(real_fd);
+                        }
+                        _ => unreachable!("We just created a Kind::File"),
+                    }
+                }
+
+                Ok(real_fd)
             }
             _ => Err(FsError::BaseNotDirectory),
         }
@@ -866,7 +938,7 @@ impl WasiFs {
                     // happy path
                     let guard = base_inode.read();
                     match guard.deref() {
-                        Kind::File { ref handle, .. } => {
+                        Kind::File { handle, .. } => {
                             if let Some(handle) = handle {
                                 let mut handle = handle.write().unwrap();
                                 std::mem::swap(handle.deref_mut(), &mut file);
@@ -879,7 +951,7 @@ impl WasiFs {
                 // slow path
                 let mut guard = base_inode.write();
                 match guard.deref_mut() {
-                    Kind::File { ref mut handle, .. } => {
+                    Kind::File { handle, .. } => {
                         if let Some(handle) = handle {
                             let mut handle = handle.write().unwrap();
                             std::mem::swap(handle.deref_mut(), &mut file);
@@ -984,6 +1056,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
@@ -994,9 +1073,9 @@ impl WasiFs {
                 match guard.deref_mut() {
                     Kind::Buffer { .. } => unimplemented!("state::get_inode_at_path for buffers"),
                     Kind::Dir {
-                        ref mut entries,
-                        ref path,
-                        ref parent,
+                        entries,
+                        path,
+                        parent,
                         ..
                     } => {
                         match component.as_os_str().to_string_lossy().borrow() {
@@ -1084,7 +1163,9 @@ impl WasiFs {
                                         // a `SocketDgram`?
                                         Filetype::SocketStream
                                     } else {
-                                        unimplemented!("state::get_inode_at_path unknown file type: not file, directory, symlink, char device, block device, fifo, or socket");
+                                        unimplemented!(
+                                            "state::get_inode_at_path unknown file type: not file, directory, symlink, char device, block device, fifo, or socket"
+                                        );
                                     };
 
                                     let kind = Kind::File {
@@ -1110,10 +1191,7 @@ impl WasiFs {
                                     );
 
                                     let mut guard = cur_inode.write();
-                                    if let Kind::Dir {
-                                        ref mut entries, ..
-                                    } = guard.deref_mut()
-                                    {
+                                    if let Kind::Dir { entries, .. } = guard.deref_mut() {
                                         entries.insert(
                                             component.as_os_str().to_string_lossy().to_string(),
                                             new_inode.clone(),
@@ -1127,7 +1205,9 @@ impl WasiFs {
                                     return Ok(new_inode);
                                 }
                                 #[cfg(not(unix))]
-                                unimplemented!("state::get_inode_at_path unknown file type: not file, directory, or symlink");
+                                unimplemented!(
+                                    "state::get_inode_at_path unknown file type: not file, directory, or symlink"
+                                );
                             };
                             drop(guard);
 
@@ -1139,10 +1219,7 @@ impl WasiFs {
                             )?;
                             if should_insert {
                                 let mut guard = processing_cur_inode.write();
-                                if let Kind::Dir {
-                                    ref mut entries, ..
-                                } = guard.deref_mut()
-                                {
+                                if let Kind::Dir { entries, .. } = guard.deref_mut() {
                                     entries.insert(
                                         component.as_os_str().to_string_lossy().to_string(),
                                         new_inode.clone(),
@@ -1180,7 +1257,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 +1335,7 @@ impl WasiFs {
             },
         }
 
-        impl<'a> BaseFdAndRelPath<'a> {
+        impl BaseFdAndRelPath<'_> {
             const fn max_seen(&self) -> usize {
                 match self {
                     Self::None => 0,
@@ -1268,7 +1347,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 +1423,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 +1455,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 +1485,7 @@ impl WasiFs {
         self.fd_map
             .read()
             .unwrap()
-            .get(&fd)
+            .get(fd)
             .ok_or(Errno::Badf)
             .map(|a| a.inode.clone())
     }
@@ -1422,7 +1504,7 @@ impl WasiFs {
                     fs_flags: Fdflags::empty(),
                     fs_rights_base: STDIN_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             __WASI_STDOUT_FILENO => {
                 return Ok(Fdstat {
@@ -1430,7 +1512,7 @@ impl WasiFs {
                     fs_flags: Fdflags::APPEND,
                     fs_rights_base: STDOUT_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             __WASI_STDERR_FILENO => {
                 return Ok(Fdstat {
@@ -1438,7 +1520,7 @@ impl WasiFs {
                     fs_flags: Fdflags::APPEND,
                     fs_rights_base: STDERR_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             VIRTUAL_ROOT_FD => {
                 return Ok(Fdstat {
@@ -1474,9 +1556,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?
         })
     }
 
@@ -1495,10 +1577,8 @@ impl WasiFs {
         Prestat {
             pr_type: Preopentype::Dir,
             u: PrestatEnum::Dir {
-                // 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,
+                // WASI spec: pr_name_len is the length of the path string, NOT including null terminator
+                pr_name_len: inode_val.name.read().unwrap().len() as u32,
             }
             .untagged(),
         }
@@ -1520,7 +1600,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 +1689,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 +1698,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 +1893,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 +1930,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 +1972,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 +2036,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 +2053,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 +2072,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 +2107,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,12 +2160,14 @@ 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 { .. } => {
-                        self.root_fs.symlink_metadata(path_to_symlink).map_err(fs_error_into_wasi_err)?
-                    }
+                    Kind::Root { .. } => self
+                        .root_fs
+                        .symlink_metadata(path_to_symlink)
+                        .map_err(fs_error_into_wasi_err)?,
                     Kind::Dir { path, .. } => {
                         let mut real_path = path.clone();
                         // PHASE 1: ignore all possible symlinks in `relative_path`
@@ -2059,10 +2177,14 @@ impl WasiFs {
                         // TODO: adjust size of symlink, too
                         //      for all paths adjusted think about this
                         real_path.push(path_to_symlink);
-                        self.root_fs.symlink_metadata(&real_path).map_err(fs_error_into_wasi_err)?
+                        self.root_fs
+                            .symlink_metadata(&real_path)
+                            .map_err(fs_error_into_wasi_err)?
                     }
                     // if this triggers, there's a bug in the symlink code
-                    _ => unreachable!("Symlink pointing to something that's not a directory as its base preopened directory"),
+                    _ => unreachable!(
+                        "Symlink pointing to something that's not a directory as its base preopened directory"
+                    ),
                 }
             }
             _ => return Err(Errno::Io),
@@ -2081,12 +2203,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,20 +2229,29 @@ 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)
     }
 }
 
 /// Returns the default filesystem backing
-pub fn default_fs_backing() -> Box<dyn virtual_fs::FileSystem + Send + Sync> {
+pub fn default_fs_backing() -> Arc<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())
+            Arc::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()
+            Arc::<virtual_fs::mem_fs::FileSystem>::default()
         } else {
-            Box::<FallbackFileSystem>::default()
+            Arc::<FallbackFileSystem>::default()
         }
     }
 }
@@ -2133,7 +2261,9 @@ pub struct FallbackFileSystem;
 
 impl FallbackFileSystem {
     fn fail() -> ! {
-        panic!("No filesystem set for wasmer-wasi, please enable either the `host-fs` or `mem-fs` feature or set your custom filesystem with `WasiEnvBuilder::set_fs`");
+        panic!(
+            "No filesystem set for wasmer-wasi, please enable either the `host-fs` or `mem-fs` feature or set your custom filesystem with `WasiEnvBuilder::set_fs`"
+        );
     }
 }
 
@@ -2162,7 +2292,7 @@ impl FileSystem for FallbackFileSystem {
     fn remove_file(&self, _path: &Path) -> Result<(), FsError> {
         Self::fail();
     }
-    fn new_open_options(&self) -> virtual_fs::OpenOptions {
+    fn new_open_options(&self) -> virtual_fs::OpenOptions<'_> {
         Self::fail();
     }
     fn mount(
@@ -2244,3 +2374,94 @@ pub fn fs_error_into_wasi_err(fs_error: FsError) -> Errno {
         FsError::Unsupported => Errno::Notsup,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_relative_path_to_absolute() {
+        let inodes = WasiInodes::new();
+        let fs_backing = WasiFsRoot::Sandbox(TmpFileSystem::new());
+        let wasi_fs = WasiFs::new_init(fs_backing, &inodes, FS_ROOT_INO).unwrap();
+
+        // Test absolute path (returned as-is, no normalization)
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("/foo/bar".to_string()),
+            "/foo/bar"
+        );
+        assert_eq!(wasi_fs.relative_path_to_absolute("/".to_string()), "/");
+
+        // Absolute paths with special components are not normalized
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("//foo//bar//".to_string()),
+            "//foo//bar//"
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("/a/b/./c".to_string()),
+            "/a/b/./c"
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("/a/b/../c".to_string()),
+            "/a/b/../c"
+        );
+
+        // Test relative path with root as current dir
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("foo/bar".to_string()),
+            "/foo/bar"
+        );
+        assert_eq!(wasi_fs.relative_path_to_absolute("foo".to_string()), "/foo");
+
+        // Test with different current directory
+        wasi_fs.set_current_dir("/home/user");
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("file.txt".to_string()),
+            "/home/user/file.txt"
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("dir/file.txt".to_string()),
+            "/home/user/dir/file.txt"
+        );
+
+        // Test relative paths with . and .. components
+        wasi_fs.set_current_dir("/a/b/c");
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("./file.txt".to_string()),
+            "/a/b/c/./file.txt"
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("../file.txt".to_string()),
+            "/a/b/c/../file.txt"
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("../../file.txt".to_string()),
+            "/a/b/c/../../file.txt"
+        );
+
+        // Test edge cases
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute(".".to_string()),
+            "/a/b/c/."
+        );
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("..".to_string()),
+            "/a/b/c/.."
+        );
+        assert_eq!(wasi_fs.relative_path_to_absolute("".to_string()), "/a/b/c/");
+
+        // Test current directory with trailing slash
+        wasi_fs.set_current_dir("/home/user/");
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("file.txt".to_string()),
+            "/home/user/file.txt"
+        );
+
+        // Test current directory without trailing slash
+        wasi_fs.set_current_dir("/home/user");
+        assert_eq!(
+            wasi_fs.relative_path_to_absolute("file.txt".to_string()),
+            "/home/user/file.txt"
+        );
+    }
+}
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/fs/relative_path_hack.rs b/lib/wasix/src/fs/relative_path_hack.rs
new file mode 100644
index 0000000000..40d6145d7b
--- /dev/null
+++ b/lib/wasix/src/fs/relative_path_hack.rs
@@ -0,0 +1,91 @@
+use std::{path::Path, sync::Arc};
+
+use futures::future::BoxFuture;
+use virtual_fs::{FileSystem, FsError, OpenOptions, OpenOptionsConfig};
+
+#[derive(Debug)]
+pub struct RelativeOrAbsolutePathHack<F>(pub F);
+
+impl<F: FileSystem> RelativeOrAbsolutePathHack<F> {
+    fn execute<Func, Ret>(&self, path: &Path, operation: Func) -> Result<Ret, FsError>
+    where
+        Func: Fn(&F, &Path) -> Result<Ret, FsError>,
+    {
+        // First, try it with the path we were given
+        let result = operation(&self.0, path);
+
+        if result.is_err() && !path.is_absolute() {
+            // we were given a relative path, but maybe the operation will work
+            // using absolute paths instead.
+            let path = Path::new("/").join(path);
+            operation(&self.0, &path)
+        } else {
+            result
+        }
+    }
+}
+
+impl<F: FileSystem> virtual_fs::FileSystem for RelativeOrAbsolutePathHack<F> {
+    fn readlink(&self, path: &Path) -> virtual_fs::Result<std::path::PathBuf> {
+        self.execute(path, |fs, p| fs.readlink(p))
+    }
+
+    fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
+        self.execute(path, |fs, p| fs.read_dir(p))
+    }
+
+    fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.create_dir(p))
+    }
+
+    fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.remove_dir(p))
+    }
+
+    fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        Box::pin(async move { self.0.rename(&from, &to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        self.execute(path, |fs, p| fs.metadata(p))
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        self.execute(path, |fs, p| fs.symlink_metadata(p))
+    }
+
+    fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.remove_file(p))
+    }
+
+    fn new_open_options(&self) -> OpenOptions<'_> {
+        virtual_fs::OpenOptions::new(self)
+    }
+
+    fn mount(
+        &self,
+        name: String,
+        path: &Path,
+        fs: Box<dyn FileSystem + Send + Sync>,
+    ) -> virtual_fs::Result<()> {
+        let name_ref = &name;
+        let f_ref = &Arc::new(fs);
+        self.execute(path, move |f, p| {
+            f.mount(name_ref.clone(), p, Box::new(f_ref.clone()))
+        })
+    }
+}
+
+impl<F: FileSystem> virtual_fs::FileOpener for RelativeOrAbsolutePathHack<F> {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> virtual_fs::Result<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>> {
+        self.execute(path, |fs, p| {
+            fs.new_open_options().options(conf.clone()).open(p)
+        })
+    }
+}
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..cbb32cb037 100644
--- a/lib/wasix/src/http/reqwest.rs
+++ b/lib/wasix/src/http/reqwest.rs
@@ -1,7 +1,7 @@
-use std::{env, time::Duration};
+use std::time::Duration;
 
 use anyhow::Context;
-use futures::{future::BoxFuture, TryStreamExt};
+use futures::{TryStreamExt, future::BoxFuture};
 use std::convert::TryFrom;
 use tokio::runtime::Handle;
 
@@ -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/http/web_http_client.rs b/lib/wasix/src/http/web_http_client.rs
index 764cf211b9..258bac6824 100644
--- a/lib/wasix/src/http/web_http_client.rs
+++ b/lib/wasix/src/http/web_http_client.rs
@@ -8,9 +8,9 @@ use wasm_bindgen_futures::JsFuture;
 use web_sys::{RequestInit, RequestMode, Window, WorkerGlobalScope};
 
 use crate::{
+    VirtualTaskManager, WasiThreadError,
     http::{HttpClient, HttpRequest, HttpRequestOptions, HttpResponse},
     utils::web::js_error,
-    VirtualTaskManager, WasiThreadError,
 };
 
 #[derive(Debug, Default, Clone)]
diff --git a/lib/wasix/src/journal/effector/memory_and_snapshot.rs b/lib/wasix/src/journal/effector/memory_and_snapshot.rs
index ee9573af73..b7c587a30b 100644
--- a/lib/wasix/src/journal/effector/memory_and_snapshot.rs
+++ b/lib/wasix/src/journal/effector/memory_and_snapshot.rs
@@ -1,4 +1,4 @@
-use std::collections::{hash_map, BTreeMap};
+use std::collections::{BTreeMap, hash_map};
 
 #[allow(unused)]
 use lz4_flex::{
@@ -207,7 +207,7 @@ impl JournalEffector {
         let (env, mut store) = ctx.data_and_store_mut();
 
         let (uncompressed_size, compressed_data) = block::uncompressed_size(compressed_data)
-            .map_err(|err| anyhow::anyhow!("failed to decompress - {}", err))?;
+            .map_err(|err| anyhow::anyhow!("failed to decompress - {err}"))?;
 
         let memory = unsafe { env.memory() };
         memory.grow_at_least(&mut store, region.end + uncompressed_size as u64)?;
diff --git a/lib/wasix/src/journal/effector/mod.rs b/lib/wasix/src/journal/effector/mod.rs
index 45fb3f7767..e696b3ecd8 100644
--- a/lib/wasix/src/journal/effector/mod.rs
+++ b/lib/wasix/src/journal/effector/mod.rs
@@ -7,17 +7,16 @@ 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,
     },
 };
 
 pub(super) use crate::{
-    mem_error_to_wasi,
+    WasiEnv, WasiThreadId, mem_error_to_wasi,
     os::task::process::WasiProcessInner,
-    syscalls::{fd_write_internal, FdWriteSource},
+    syscalls::{FdWriteSource, fd_write_internal},
     utils::map_snapshot_err,
-    WasiEnv, WasiThreadId,
 };
 
 use super::*;
@@ -37,6 +36,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 +69,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..0f4e1dbbf8 100644
--- a/lib/wasix/src/journal/effector/process_exit.rs
+++ b/lib/wasix/src/journal/effector/process_exit.rs
@@ -1,4 +1,4 @@
-use virtual_mio::InlineWaker;
+use virtual_mio::block_on;
 
 use super::*;
 
@@ -25,13 +25,18 @@ impl JournalEffector {
         // any signals
         if env.replaying_journal {
             let state = env.state.clone();
-            InlineWaker::block_on(state.fs.close_all());
+            block_on(state.fs.close_all());
         } else {
             env.blocking_on_exit(exit_code);
         }
 
         // 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..88001f003a 100644
--- a/lib/wasix/src/journal/effector/syscalls/chdir.rs
+++ b/lib/wasix/src/journal/effector/syscalls/chdir.rs
@@ -6,11 +6,9 @@ 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,
-                err
+                "snapshot restore error: failed to change directory (path={path}) - {err}"
             )
         })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/clock_time.rs b/lib/wasix/src/journal/effector/syscalls/clock_time.rs
index c196732dfe..a1e447210f 100644
--- a/lib/wasix/src/journal/effector/syscalls/clock_time.rs
+++ b/lib/wasix/src/journal/effector/syscalls/clock_time.rs
@@ -17,10 +17,7 @@ impl JournalEffector {
         let ret = crate::syscalls::clock_time_set_internal(ctx, clock_id, time);
         if ret != Errno::Success {
             bail!(
-                "journal restore error: failed to set clock time (clock_id={:?}, time={}) - {}",
-                clock_id,
-                time,
-                ret
+                "journal restore error: failed to set clock time (clock_id={clock_id:?}, time={time}) - {ret}"
             );
         }
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/epoll_create.rs b/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
index c25d9608bf..d228ad0f61 100644
--- a/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
+++ b/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
@@ -8,19 +8,19 @@ impl JournalEffector {
     pub fn apply_epoll_create(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
         let ret_fd = crate::syscalls::epoll_create_internal(ctx, Some(fd))
             .map_err(|err| {
-                anyhow::format_err!("journal restore error: failed to create epoll - {}", err)
+                anyhow::format_err!("journal restore error: failed to create epoll - {err}")
             })?
             .map_err(|err| {
-                anyhow::format_err!("journal restore error: failed to create epoll - {}", err)
+                anyhow::format_err!("journal restore error: failed to create epoll - {err}")
             })?;
 
         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/epoll_ctl.rs b/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs
index e4719999db..0438c549a4 100644
--- a/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs
+++ b/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs
@@ -29,21 +29,11 @@ impl JournalEffector {
         crate::syscalls::epoll_ctl_internal(ctx, pfd, op, fd, event.as_ref())
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to epoll ctl (pfd={}, op={:?}, fd={}) - {}",
-                    pfd,
-                    op,
-                    fd,
-                    err
-                )
+                    "journal restore error: failed to epoll ctl (pfd={pfd}, op={op:?}, fd={fd}) - {err}")
             })?
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to epoll ctl (pfd={}, op={:?}, fd={}) - {}",
-                    pfd,
-                    op,
-                    fd,
-                    err
-                )
+                    "journal restore error: failed to epoll ctl (pfd={pfd}, op={op:?}, fd={fd}) - {err}")
             })?;
 
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_advise.rs b/lib/wasix/src/journal/effector/syscalls/fd_advise.rs
index 12cd5e1780..e31f5bd762 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_advise.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_advise.rs
@@ -28,13 +28,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         crate::syscalls::fd_advise_internal(ctx, fd, offset, len, advice).map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to advise file descriptor (fd={}, offset={}, len={}, advice={:?}) - {}",
-                fd,
-                offset,
-                len,
-                advice,
-                err
-            )
+                "journal restore error: failed to advise file descriptor (fd={fd}, offset={offset}, len={len}, advice={advice:?}) - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs b/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs
index 6ecacb827e..038497ed2e 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs
@@ -22,12 +22,7 @@ impl JournalEffector {
         crate::syscalls::fd_allocate_internal(ctx, fd, offset, len)
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to allocate on file descriptor (fd={}, offset={}, len={}) - {}",
-                    fd,
-                    offset,
-                    len,
-                    err
-                )
+                    "journal restore error: failed to allocate on file descriptor (fd={fd}, offset={offset}, len={len}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_close.rs b/lib/wasix/src/journal/effector/syscalls/fd_close.rs
index 4ec6691869..8153c3eeae 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_close.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_close.rs
@@ -8,12 +8,10 @@ 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={}) - {}",
-                fd,
-                err
-            );
+            bail!("journal restore error: failed to close descriptor (fd={fd}) - {err}");
         }
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs b/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
index a53be32d4c..e5120be9f9 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,26 +21,26 @@ 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={}) - {}",
-                    original_fd,
-                    copied_fd,
-                    err
-                )
+                    "journal restore error: failed to duplicate file descriptor (original={original_fd}, copied={copied_fd}) - {err}")
             })?;
 
-        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_event.rs b/lib/wasix/src/journal/effector/syscalls/fd_event.rs
index 9416299cca..6d0f5247ba 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_event.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_event.rs
@@ -29,7 +29,7 @@ impl JournalEffector {
             .map(|r| r.map_err(|err| err.to_string()))
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
-                anyhow::format_err!("journal restore error: failed to create event - {}", err)
+                anyhow::format_err!("journal restore error: failed to create event - {err}")
             })?;
 
         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..f78ac07983 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
@@ -3,19 +3,19 @@ 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| {
-            anyhow::format_err!("journal restore error: failed to create pipe - {}", 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}")
         })?;
 
         Ok(())
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_seek.rs b/lib/wasix/src/journal/effector/syscalls/fd_seek.rs
index 7cd7787ba6..2848da120d 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_seek.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_seek.rs
@@ -21,12 +21,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         crate::syscalls::fd_seek_internal(ctx, fd, offset, whence)?.map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to seek (fd={}, offset={}, whence={:?}) - {}",
-                fd,
-                offset,
-                whence,
-                err
-            )
+                "journal restore error: failed to seek (fd={fd}, offset={offset}, whence={whence:?}) - {err}")
         })?;
         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..5f32ef4818
--- /dev/null
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs
@@ -0,0 +1,24 @@
+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={fd}, flags={flags:?}) - {err}"
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs b/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs
index 669041a88d..ccc215ae48 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs
@@ -16,10 +16,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         crate::syscalls::fd_fdstat_set_flags_internal(ctx, fd, flags).map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to set file flags (fd={}, flags={:?}) - {}",
-                fd,
-                flags,
-                err
+                "journal restore error: failed to set file flags (fd={fd}, flags={flags:?}) - {err}"
             )
         })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs b/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs
index 6d77752b17..ff34556ac1 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs
@@ -26,12 +26,7 @@ impl JournalEffector {
         crate::syscalls::fd_fdstat_set_rights_internal(ctx, fd, fs_rights_base, fs_rights_inheriting)
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set file rights (fd={}, fs_rights_base={:?}, fs_rights_inheriting={:?}) - {}",
-                    fd,
-                    fs_rights_base,
-                    fs_rights_inheriting,
-                    err
-                )
+                    "journal restore error: failed to set file rights (fd={fd}, fs_rights_base={fs_rights_base:?}, fs_rights_inheriting={fs_rights_inheriting:?}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs b/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs
index 58980c1220..0241900bfe 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs
@@ -16,11 +16,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         crate::syscalls::fd_filestat_set_size_internal(ctx, fd, st_size).map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to set file size (fd={}, st_size={}) - {}",
-                fd,
-                st_size,
-                err
-            )
+                "journal restore error: failed to set file size (fd={fd}, st_size={st_size}) - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs b/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs
index 633ba079c0..59885080f4 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs
@@ -29,13 +29,7 @@ impl JournalEffector {
         crate::syscalls::fd_filestat_set_times_internal(ctx, fd, st_atim, st_mtim, fst_flags)
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set file times (fd={}, st_atim={}, st_mtim={}, fst_flags={:?}) - {}",
-                    fd,
-                    st_atim,
-                    st_mtim,
-                    fst_flags,
-                    err
-                )
+                    "journal restore error: failed to set file times (fd={fd}, st_atim={st_atim}, st_mtim={st_mtim}, fst_flags={fst_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..3559370d7c 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]>,
@@ -61,11 +61,7 @@ impl JournalEffector {
         )?
         .map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to write to descriptor (fd={}, offset={}) - {}",
-                fd,
-                offset,
-                err
-            )
+                "journal restore error: failed to write to descriptor (fd={fd}, offset={offset}) - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs b/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs
index 223bce3fd3..bcca490505 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs
@@ -32,11 +32,7 @@ impl JournalEffector {
         } else {
             crate::syscalls::path_create_directory_internal(ctx, fd, path).map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to create directory path (fd={}, path={}) - {}",
-                    fd,
-                    path,
-                    err
-                )
+                    "journal restore error: failed to create directory path (fd={fd}, path={path}) - {err}")
             })?;
         }
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/path_link.rs b/lib/wasix/src/journal/effector/syscalls/path_link.rs
index 822f671d09..a1eb20e61c 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_link.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_link.rs
@@ -32,14 +32,7 @@ impl JournalEffector {
         crate::syscalls::path_link_internal(ctx, old_fd, old_flags, old_path, new_fd, new_path)
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to create hard link (old_fd={}, old_flags={}, old_path={}, new_fd={}, new_path={}) - {}",
-                    old_fd,
-                    old_flags,
-                    old_path,
-                    new_fd,
-                    new_path,
-                    err
-                )
+                    "journal restore error: failed to create hard link (old_fd={old_fd}, old_flags={old_flags}, old_path={old_path}, new_fd={new_fd}, new_path={new_path}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/path_open.rs b/lib/wasix/src/journal/effector/syscalls/path_open.rs
index ccd7cdec98..17ef8b8aaf 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,16 +52,14 @@ impl JournalEffector {
             fs_rights_base,
             fs_rights_inheriting,
             fs_flags,
+            fd_flags,
             Some(fd),
         );
         match res? {
             Ok(fd) => fd,
             Err(err) => {
                 bail!(
-                    "journal restore error: failed to open descriptor (fd={}, path={}) - {}",
-                    fd,
-                    path,
-                    err
+                    "journal restore error: failed to open descriptor (fd={fd}, path={path}) - {err}"
                 );
             }
         };
diff --git a/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs b/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs
index f26fb5d99f..e25fa3e2d8 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs
@@ -30,10 +30,7 @@ impl JournalEffector {
         if fd == VIRTUAL_ROOT_FD {
             ctx.data().state.fs.root_fs.remove_dir(Path::new(path))?;
         } else if let Err(err) = crate::syscalls::path_remove_directory_internal(ctx, fd, path) {
-            bail!(
-                "journal restore error: failed to remove directory - {}",
-                err
-            );
+            bail!("journal restore error: failed to remove directory - {err}");
         }
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/path_rename.rs b/lib/wasix/src/journal/effector/syscalls/path_rename.rs
index 63d66dd653..77e35572a1 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_rename.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_rename.rs
@@ -1,4 +1,4 @@
-use crate::{syscalls::__asyncify_light, VIRTUAL_ROOT_FD};
+use crate::{VIRTUAL_ROOT_FD, syscalls::__asyncify_light};
 
 use super::*;
 
@@ -41,12 +41,7 @@ impl JournalEffector {
                 crate::syscalls::path_rename_internal(ctx, old_fd, old_path, new_fd, new_path)?;
             if ret != Errno::Success {
                 bail!(
-                    "journal restore error: failed to rename path (old_fd={}, old_path={}, new_fd={}, new_path={}) - {}",
-                    old_fd,
-                    old_path,
-                    new_fd,
-                    new_path,
-                    ret
+                    "journal restore error: failed to rename path (old_fd={old_fd}, old_path={old_path}, new_fd={new_fd}, new_path={new_path}) - {ret}"
                 );
             }
         }
diff --git a/lib/wasix/src/journal/effector/syscalls/path_set_times.rs b/lib/wasix/src/journal/effector/syscalls/path_set_times.rs
index 440acc2c8e..ca72f52f66 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_set_times.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_set_times.rs
@@ -41,15 +41,7 @@ impl JournalEffector {
             crate::syscalls::path_filestat_set_times_internal(ctx, fd, flags, path, st_atim, st_mtim, fst_flags)
                 .map_err(|err| {
                     anyhow::format_err!(
-                        "journal restore error: failed to set path times (fd={}, flags={}, path={}, st_atim={}, st_mtim={}, fst_flags={:?}) - {}",
-                        fd,
-                        flags,
-                        path,
-                        st_atim,
-                        st_mtim,
-                        fst_flags,
-                        err
-                    )
+                        "journal restore error: failed to set path times (fd={fd}, flags={flags}, path={path}, st_atim={st_atim}, st_mtim={st_mtim}, fst_flags={fst_flags:?}) - {err}")
                 })?;
         }
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/path_symlink.rs b/lib/wasix/src/journal/effector/syscalls/path_symlink.rs
index 60591cae7c..1301ee7b0f 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_symlink.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_symlink.rs
@@ -26,12 +26,7 @@ impl JournalEffector {
         crate::syscalls::path_symlink_internal(ctx, old_path, fd, new_path)
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to create symlink (old_path={}, fd={}, new_path={}) - {}",
-                    old_path,
-                    fd,
-                    new_path,
-                    err
-                )
+                    "journal restore error: failed to create symlink (old_path={old_path}, fd={fd}, new_path={new_path}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/path_unlink.rs b/lib/wasix/src/journal/effector/syscalls/path_unlink.rs
index 035d2e905b..a8307b37c4 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_unlink.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_unlink.rs
@@ -33,10 +33,7 @@ impl JournalEffector {
             let ret = crate::syscalls::path_unlink_file_internal(ctx, fd, path)?;
             if ret != Errno::Success {
                 bail!(
-                    "journal restore error: failed to remove file (fd={}, path={}) - {}",
-                    fd,
-                    path,
-                    ret
+                    "journal restore error: failed to remove file (fd={fd}, path={path}) - {ret}"
                 );
             }
         }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs b/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs
index ae508e774e..b57ccb32e6 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs
@@ -19,10 +19,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to add address to port file descriptor (cidr={:?}) - {}",
-                    cidr,
-                    err
-                )
+                    "journal restore error: failed to add address to port file descriptor (cidr={cidr:?}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs b/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs
index d68a2a8e4c..c6f9c5b8db 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs
@@ -10,10 +10,7 @@ impl JournalEffector {
             .map(|r| r.map_err(|err| err.to_string()))
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
-                anyhow::format_err!(
-                    "journal restore error: failed to clear port addresses - {}",
-                    err
-                )
+                anyhow::format_err!("journal restore error: failed to clear port addresses - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs b/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs
index b2d46f926d..c2442cf147 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs
@@ -19,9 +19,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to remove address from port (ip={}) - {}",
-                    addr,
-                    err
+                    "journal restore error: failed to remove address from port (ip={addr}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/port_bridge.rs b/lib/wasix/src/journal/effector/syscalls/port_bridge.rs
index bdfd5ce54d..2be144607c 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_bridge.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_bridge.rs
@@ -30,11 +30,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to bridge the network file descriptor (network={}, security={:?}) - {}",
-                    network,
-                    security,
-                    err
-                )
+                    "journal restore error: failed to bridge the network file descriptor (network={network}, security={security:?}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs b/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs
index 98ef069b18..d390682dda 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs
@@ -10,10 +10,7 @@ impl JournalEffector {
             .map(|r| r.map_err(|err| err.to_string()))
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
-                anyhow::format_err!(
-                    "journal restore error: failed to acquire DHCP address - {}",
-                    err
-                )
+                anyhow::format_err!("journal restore error: failed to acquire DHCP address - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs b/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs
index a0251a02e8..d3d4de3ad7 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs
@@ -19,9 +19,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set gateway address (ip={}) - {}",
-                    ip,
-                    err
+                    "journal restore error: failed to set gateway address (ip={ip}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/port_route_add.rs b/lib/wasix/src/journal/effector/syscalls/port_route_add.rs
index e2f44eb84e..9b366db99a 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_route_add.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_route_add.rs
@@ -40,13 +40,7 @@ impl JournalEffector {
         .unwrap_or_else(|err| Err(err.to_string()))
         .map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to add route (cidr={:?}, via_router={}, preferred_until={:?}, expires_at={:?}) - {}",
-                cidr,
-                via_router,
-                preferred_until,
-                expires_at,
-                err
-            )
+                "journal restore error: failed to add route (cidr={cidr:?}, via_router={via_router}, preferred_until={preferred_until:?}, expires_at={expires_at:?}) - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs b/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs
index dfb1774d10..630f218a0e 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs
@@ -10,10 +10,7 @@ impl JournalEffector {
             .map(|r| r.map_err(|err| err.to_string()))
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
-                anyhow::format_err!(
-                    "journal restore error: failed to clear routing table - {}",
-                    err
-                )
+                anyhow::format_err!("journal restore error: failed to clear routing table - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs b/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs
index 3a980bfff6..50355f803d 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs
@@ -19,9 +19,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to remove route (ip={}) - {}",
-                    ip,
-                    err
+                    "journal restore error: failed to remove route (ip={ip}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs b/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs
index 0fc1ae98d4..bf59d9b8c1 100644
--- a/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs
+++ b/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs
@@ -10,10 +10,7 @@ impl JournalEffector {
             .map(|r| r.map_err(|err| err.to_string()))
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
-                anyhow::format_err!(
-                    "journal restore error: failed to un-bridge network - {}",
-                    err
-                )
+                anyhow::format_err!("journal restore error: failed to un-bridge network - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_accept.rs b/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
index 73b0c33454..b27aa53209 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
@@ -90,11 +90,12 @@ 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 - {}",
-                err
+                "journal restore error: failed to create remote accepted socket - {err}"
             )
         })?;
 
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_bind.rs b/lib/wasix/src/journal/effector/syscalls/sock_bind.rs
index 73c3e3a7b8..e812064d59 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_bind.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_bind.rs
@@ -21,11 +21,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to bind socket to address (fd={}, addr={}) - {}",
-                    fd,
-                    addr,
-                    err
-                )
+                    "journal restore error: failed to bind socket to address (fd={fd}, addr={addr}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_connect.rs b/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
index b5748d63c8..f12787ee66 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
@@ -74,11 +74,18 @@ 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 - {}",
-                    err
+                    "journal restore error: failed to create remote connected socket - {err}"
                 )
             })?;
 
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs b/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs
index 589bb08caf..6436042ceb 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs
@@ -30,12 +30,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to join ipv4 multicast (fd={}, multiaddr={:?}, iface={:?}) - {}",
-                    fd,
-                    multiaddr,
-                    iface,
-                    err
-                )
+                    "journal restore error: failed to join ipv4 multicast (fd={fd}, multiaddr={multiaddr:?}, iface={iface:?}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs b/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs
index 17e7d87579..906cf3971c 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs
@@ -30,12 +30,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to join ipv6 multicast (fd={}, multiaddr={}, iface={}) - {}",
-                    fd,
-                    multiaddr,
-                    iface,
-                    err
-                )
+                    "journal restore error: failed to join ipv6 multicast (fd={fd}, multiaddr={multiaddr}, iface={iface}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs b/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs
index 9fd3b78eba..b5f49b9333 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs
@@ -30,12 +30,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to leave ipv4 multicast (fd={}, multiaddr={}, iface={}) - {}",
-                    fd,
-                    multiaddr,
-                    iface,
-                    err
-                )
+                    "journal restore error: failed to leave ipv4 multicast (fd={fd}, multiaddr={multiaddr}, iface={iface}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs b/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs
index b91f71093b..f37255c1e8 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs
@@ -30,12 +30,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to leave ipv6 multicast (fd={}, multiaddr={}, iface={}) - {}",
-                    fd,
-                    multiaddr,
-                    iface,
-                    err
-                )
+                    "journal restore error: failed to leave ipv6 multicast (fd={fd}, multiaddr={multiaddr}, iface={iface}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_listen.rs b/lib/wasix/src/journal/effector/syscalls/sock_listen.rs
index 40a420a201..96d2e00012 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_listen.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_listen.rs
@@ -25,11 +25,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to listen on socket (fd={}, backlog={}) - {}",
-                    fd,
-                    backlog,
-                    err
-                )
+                    "journal restore error: failed to listen on socket (fd={fd}, backlog={backlog}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_open.rs b/lib/wasix/src/journal/effector/syscalls/sock_open.rs
index 2b2433608a..4d5b9c9090 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_open.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_open.rs
@@ -23,21 +23,11 @@ impl JournalEffector {
         crate::syscalls::sock_open_internal(ctx, af, ty, pt, Some(fd))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to open socket (af={:?}, ty={:?}, pt={:?}) - {}",
-                    af,
-                    ty,
-                    pt,
-                    err
-                )
+                    "journal restore error: failed to open socket (af={af:?}, ty={ty:?}, pt={pt:?}) - {err}")
             })?
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to open socket (af={:?}, ty={:?}, pt={:?}) - {}",
-                    af,
-                    ty,
-                    pt,
-                    err
-                )
+                    "journal restore error: failed to open socket (af={af:?}, ty={ty:?}, pt={pt:?}) - {err}")
             })?;
         Ok(())
     }
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..b615a6e6f7
--- /dev/null
+++ b/lib/wasix/src/journal/effector/syscalls/sock_pair.rs
@@ -0,0 +1,27 @@
+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.rs b/lib/wasix/src/journal/effector/syscalls/sock_send.rs
index 710b9cc922..f57feb96f5 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_send.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_send.rs
@@ -54,11 +54,7 @@ impl JournalEffector {
         sock_send_internal(ctx, sock, FdWriteSource::<'_, M>::Buffer(si_data), si_flags)?.map_err(
             |err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to send on socket (fd={}, data.len={}) - {}",
-                    sock,
-                    data_len,
-                    err
-                )
+                    "journal restore error: failed to send on socket (fd={sock}, data.len={data_len}) - {err}")
             },
         )?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs b/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs
index abf21efb9e..7879056a91 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs
@@ -30,13 +30,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         sock_send_file_internal(ctx, socket_fd, file_fd, offset, count)?.map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to send_file on socket (sock={}, in_fd={}, offset={}, count={}) - {}",
-                socket_fd,
-                file_fd,
-                offset,
-                count,
-                err
-            )
+                "journal restore error: failed to send_file on socket (sock={socket_fd}, in_fd={file_fd}, offset={offset}, count={count}) - {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..a035caa80f 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,
@@ -64,11 +64,7 @@ impl JournalEffector {
         )?
         .map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to send_to on socket (fd={}, data.len={}) - {}",
-                sock,
-                data_len,
-                err
-            )
+                "journal restore error: failed to send_to on socket (fd={sock}, data.len={data_len}) - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs
index ead9f50933..6c1c743c5c 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs
@@ -23,12 +23,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set socket option (fd={}, opt={:?}, flag={}) - {}",
-                    fd,
-                    opt,
-                    flag,
-                    err
-                )
+                    "journal restore error: failed to set socket option (fd={fd}, opt={opt:?}, flag={flag}) - {err}")
             })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs
index 867f351225..c8ac47b213 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs
@@ -23,11 +23,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set socket option (fd={}, opt={:?}, size={}) - {}",
-                    fd,
-                    opt,
-                    size,
-                    err
+                    "journal restore error: failed to set socket option (fd={fd}, opt={opt:?}, size={size}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs
index 0dbdf7ab33..eac3283da2 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs
@@ -32,11 +32,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to set socket option (fd={}, opt={:?}, time={:?}) - {}",
-                    fd,
-                    ty,
-                    time,
-                    err
+                    "journal restore error: failed to set socket option (fd={fd}, opt={ty:?}, time={time:?}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs b/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs
index 61497214b7..37dcf5ea2a 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs
@@ -27,10 +27,7 @@ impl JournalEffector {
             .unwrap_or_else(|err| Err(err.to_string()))
             .map_err(|err| {
                 anyhow::format_err!(
-                    "journal restore error: failed to shutdown socket (fd={}, how={:?}) - {}",
-                    fd,
-                    shutdown,
-                    err
+                    "journal restore error: failed to shutdown socket (fd={fd}, how={shutdown:?}) - {err}"
                 )
             })?;
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/tty_set.rs b/lib/wasix/src/journal/effector/syscalls/tty_set.rs
index 536c5a3a2f..9f8b1f82cd 100644
--- a/lib/wasix/src/journal/effector/syscalls/tty_set.rs
+++ b/lib/wasix/src/journal/effector/syscalls/tty_set.rs
@@ -31,7 +31,7 @@ impl JournalEffector {
         state: WasiTtyState,
     ) -> anyhow::Result<()> {
         crate::syscalls::tty_set_internal(ctx, state).map_err(|err| {
-            anyhow::format_err!("journal restore error: failed to set tty - {}", err)
+            anyhow::format_err!("journal restore error: failed to set tty - {err}")
         })?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/thread_state.rs b/lib/wasix/src/journal/effector/thread_state.rs
index 0c824b6bb3..c437a775b4 100644
--- a/lib/wasix/src/journal/effector/thread_state.rs
+++ b/lib/wasix/src/journal/effector/thread_state.rs
@@ -3,9 +3,9 @@ use std::sync::Arc;
 use wasmer_wasix_types::wasix::ThreadStartType;
 
 use crate::{
+    RewindState,
     os::task::thread::{RewindResultType, WasiMemoryLayout},
     syscalls::thread_spawn_internal_using_layout,
-    RewindState,
 };
 
 use super::*;
@@ -83,7 +83,7 @@ impl JournalEffector {
                 RewindResultType::RewindRestart,
             )),
         )
-        .map_err(|err| anyhow::format_err!("failed to spawn thread - {}", err))?;
+        .map_err(|err| anyhow::format_err!("failed to spawn thread - {err}"))?;
 
         Ok(())
     }
diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs
index 3f93f3c22d..0ced28de08 100644
--- a/lib/wasix/src/lib.rs
+++ b/lib/wasix/src/lib.rs
@@ -1,8 +1,9 @@
 // FIXME: merge with ./lib.rs_upstream
 
+#![allow(clippy::result_large_err)]
 #![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))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 //! Wasmer's WASI implementation
 //!
@@ -14,12 +15,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 +37,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"))]
@@ -61,14 +71,13 @@ use std::sync::Arc;
 use bytes::{Bytes, BytesMut};
 use os::task::control_plane::ControlPlaneError;
 use thiserror::Error;
-use tracing::error;
 // re-exports needed for OS
 pub use wasmer;
 pub use wasmer_wasix_types;
 
 use wasmer::{
-    imports, namespace, AsStoreMut, Exports, FunctionEnv, Imports, Memory32, MemoryAccessError,
-    MemorySize, RuntimeError,
+    AsStoreMut, Exports, FunctionEnv, Imports, Memory32, MemoryAccessError, MemorySize,
+    RuntimeError, imports, namespace,
 };
 
 pub use virtual_fs;
@@ -84,27 +93,26 @@ pub use virtual_net::{
 use wasmer_wasix_types::wasi::{Errno, ExitCode};
 
 pub use crate::{
-    fs::{default_fs_backing, Fd, WasiFs, WasiInodes, VIRTUAL_ROOT_FD},
+    fs::{Fd, VIRTUAL_ROOT_FD, WasiFs, WasiInodes, default_fs_backing},
     os::{
+        WasiTtyState,
         task::{
             control_plane::WasiControlPlane,
             process::{WasiProcess, WasiProcessId},
             thread::{WasiThread, WasiThreadError, WasiThreadHandle, WasiThreadId},
         },
-        WasiTtyState,
     },
     rewind::*,
-    runtime::{task_manager::VirtualTaskManager, PluggableRuntime, Runtime},
+    runtime::{PluggableRuntime, Runtime, task_manager::VirtualTaskManager},
     state::{
-        WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiInstanceHandles,
-        WasiStateCreationError, ALL_RIGHTS,
+        ALL_RIGHTS, WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv,
+        WasiModuleInstanceHandles, WasiModuleTreeHandles, WasiStateCreationError,
     },
     syscalls::{journal::wait_for_snapshot, rewind, rewind_ext, types, unwind},
     utils::is_wasix_module,
     utils::{
-        get_wasi_version, get_wasi_versions, is_wasi_module,
-        store::{capture_store_snapshot, restore_store_snapshot, StoreSnapshot},
-        WasiVersion,
+        WasiVersion, get_wasi_version, get_wasi_versions, is_wasi_module,
+        store::{StoreSnapshot, capture_store_snapshot, restore_store_snapshot},
     },
 };
 
@@ -114,10 +122,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 +233,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 +252,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>),
@@ -267,7 +282,7 @@ pub enum WasiRuntimeError {
 impl WasiRuntimeError {
     /// Retrieve the concrete exit code returned by an instance.
     ///
-    /// Returns [`None`] if a general execution error ocurred.
+    /// Returns [`None`] if a general execution error occurred.
     pub fn as_exit_code(&self) -> Option<ExitCode> {
         if let WasiRuntimeError::Wasi(WasiError::Exit(code)) = self {
             Some(*code)
@@ -281,48 +296,36 @@ impl WasiRuntimeError {
             None
         }
     }
-}
 
-#[allow(clippy::result_large_err)]
-pub(crate) fn run_wasi_func(
-    func: &wasmer::Function,
-    store: &mut impl AsStoreMut,
-    params: &[wasmer::Value],
-) -> Result<Box<[wasmer::Value]>, WasiRuntimeError> {
-    func.call(store, params).map_err(|err| {
-        if let Some(_werr) = err.downcast_ref::<WasiError>() {
-            let werr = err.downcast::<WasiError>().unwrap();
-            WasiRuntimeError::Wasi(werr)
+    pub fn display<'a>(&'a self, store: &'a mut impl AsStoreMut) -> WasiRuntimeErrorDisplay<'a> {
+        if let WasiRuntimeError::Runtime(err) = self {
+            WasiRuntimeErrorDisplay::Runtime(err.display(store))
         } else {
-            WasiRuntimeError::Runtime(err)
+            WasiRuntimeErrorDisplay::Other(self)
         }
-    })
+    }
 }
 
-/// Run a main function.
-///
-/// This is usually called "_start" in WASI modules.
-/// The function will not receive arguments or return values.
-///
-/// An exit code that is not 0 will be returned as a `WasiError::Exit`.
-#[allow(clippy::result_large_err)]
-pub(crate) fn run_wasi_func_start(
-    func: &wasmer::Function,
-    store: &mut impl AsStoreMut,
-) -> Result<(), WasiRuntimeError> {
-    run_wasi_func(func, store, &[])?;
-    Ok(())
+pub enum WasiRuntimeErrorDisplay<'a> {
+    Runtime(wasmer::RuntimeErrorDisplay<'a>),
+    Other(&'a WasiRuntimeError),
+}
+
+impl std::fmt::Display for WasiRuntimeErrorDisplay<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WasiRuntimeErrorDisplay::Runtime(display) => write!(f, "{display}"),
+            WasiRuntimeErrorDisplay::Other(err) => write!(f, "{err}"),
+        }
+    }
 }
 
 #[derive(Debug)]
 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
+    /// The information needed to rewind the stack with asyncify
+    pub asyncify: Option<WasiVForkAsyncify>,
+
+    /// The environment before the vfork occurred
     pub env: Box<WasiEnv>,
 
     /// Handle of the thread we have forked (dropping this handle
@@ -330,21 +333,28 @@ pub struct WasiVFork {
     pub handle: WasiThreadHandle,
 }
 
+#[derive(Debug, Clone)]
+pub struct WasiVForkAsyncify {
+    /// The unwound stack before the vfork occurred
+    pub rewind_stack: BytesMut,
+    /// The mutable parts of the store
+    pub store_data: Bytes,
+    /// Whether the store is 64-bit
+    pub 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(),
+            asyncify: self.asyncify.clone(),
             env: Box::new(self.env.as_ref().clone()),
             handle: self.handle.clone(),
         }
     }
 }
 
-/// Create an [`Imports`] with an existing [`WasiEnv`]. `WasiEnv`
-/// needs a [`WasiState`], that can be constructed from a
-/// [`WasiEnvBuilder`](state::WasiEnvBuilder).
+/// Create an [`Imports`] with an existing [`WasiEnv`]. [`WasiEnv`] values are
+/// typically constructed with [`WasiEnvBuilder`].
 pub fn generate_import_object_from_env(
     store: &mut impl AsStoreMut,
     ctx: &FunctionEnv<WasiEnv>,
@@ -361,8 +371,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,
     };
 
@@ -490,13 +499,20 @@ fn wasi_snapshot_preview1_exports(
 }
 
 fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    let engine_supports_async = store.as_store_ref().engine().supports_async();
+
     use syscalls::*;
     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 +536,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 +550,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>),
@@ -539,13 +559,20 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "poll_oneoff" => Function::new_typed_with_env(&mut store, env, poll_oneoff::<Memory32>),
         "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_fork_env" => Function::new_typed_with_env(&mut store, env, proc_fork_env::<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_exit2" => Function::new_typed_with_env(&mut store, env, proc_exit2::<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 +580,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>),
@@ -565,6 +595,9 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory32>),
         "stack_checkpoint" => Function::new_typed_with_env(&mut store, env, stack_checkpoint::<Memory32>),
         "stack_restore" => Function::new_typed_with_env(&mut store, env, stack_restore::<Memory32>),
+        "context_create" => Function::new_typed_with_env(&mut store, env, context_create::<Memory32>),
+        "context_switch" => if engine_supports_async { Function::new_typed_with_env_async(&mut store, env, context_switch) } else { Function::new_typed_with_env(&mut store, env, context_switch_not_supported) },
+        "context_destroy" => Function::new_typed_with_env(&mut store, env, context_destroy),
         "futex_wait" => Function::new_typed_with_env(&mut store, env, futex_wait::<Memory32>),
         "futex_wake" => Function::new_typed_with_env(&mut store, env, futex_wake::<Memory32>),
         "futex_wake_all" => Function::new_typed_with_env(&mut store, env, futex_wake_all::<Memory32>),
@@ -585,6 +618,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>),
@@ -612,13 +646,20 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
 }
 
 fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    let engine_supports_async = store.as_store_ref().engine().supports_async();
+
     use syscalls::*;
     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 +683,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 +697,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>),
@@ -661,13 +706,20 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "poll_oneoff" => Function::new_typed_with_env(&mut store, env, poll_oneoff::<Memory64>),
         "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_fork_env" => Function::new_typed_with_env(&mut store, env, proc_fork_env::<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_exit2" => Function::new_typed_with_env(&mut store, env, proc_exit2::<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 +727,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>),
@@ -687,6 +742,9 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory64>),
         "stack_checkpoint" => Function::new_typed_with_env(&mut store, env, stack_checkpoint::<Memory64>),
         "stack_restore" => Function::new_typed_with_env(&mut store, env, stack_restore::<Memory64>),
+        "context_create" => Function::new_typed_with_env(&mut store, env, context_create::<Memory64>),
+        "context_switch" => if engine_supports_async { Function::new_typed_with_env_async(&mut store, env, context_switch) } else { Function::new_typed_with_env(&mut store, env, context_switch_not_supported) },
+        "context_destroy" => Function::new_typed_with_env(&mut store, env, context_destroy),
         "futex_wait" => Function::new_typed_with_env(&mut store, env, futex_wait::<Memory64>),
         "futex_wake" => Function::new_typed_with_env(&mut store, env, futex_wake::<Memory64>),
         "futex_wake_all" => Function::new_typed_with_env(&mut store, env, futex_wake_all::<Memory64>),
@@ -707,6 +765,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 +792,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 +815,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
@@ -859,3 +902,22 @@ where
         }
     }
 }
+
+pub(crate) 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,
+    }
+}
diff --git a/lib/wasix/src/macros.rs b/lib/wasix/src/macros.rs
index fa2df0dfab..9355cd0bbc 100644
--- a/lib/wasix/src/macros.rs
+++ b/lib/wasix/src/macros.rs
@@ -50,56 +50,64 @@ macro_rules! wasi_try_ok_ok {
 
 /// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
 macro_rules! wasi_try_mem {
-    ($expr:expr) => {{
-        wasi_try!($expr.map_err($crate::mem_error_to_wasi))
-    }};
+    ($expr:expr) => {{ wasi_try!($expr.map_err($crate::mem_error_to_wasi)) }};
 }
 
 /// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
 macro_rules! wasi_try_mem_ok {
-    ($expr:expr) => {{
-        wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi))
-    }};
+    ($expr:expr) => {{ wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi)) }};
 
-    ($expr:expr, $thread:expr) => {{
-        wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi), $thread)
-    }};
+    ($expr:expr, $thread:expr) => {{ wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi), $thread) }};
 }
 
 /// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
 macro_rules! wasi_try_mem_ok_ok {
-    ($expr:expr) => {{
-        wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi))
-    }};
+    ($expr:expr) => {{ wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi)) }};
 
-    ($expr:expr, $thread:expr) => {{
-        wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi), $thread)
-    }};
+    ($expr:expr, $thread:expr) => {{ wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi), $thread) }};
 }
 
 /// Reads a string from Wasm memory.
 macro_rules! get_input_str {
-    ($memory:expr, $data:expr, $len:expr) => {{
-        wasi_try_mem!($data.read_utf8_string($memory, $len))
-    }};
+    ($memory:expr, $data:expr, $len:expr) => {{ wasi_try_mem!($data.read_utf8_string($memory, $len)) }};
 }
 
 macro_rules! get_input_str_ok {
-    ($memory:expr, $data:expr, $len:expr) => {{
-        wasi_try_mem_ok!($data.read_utf8_string($memory, $len))
-    }};
+    ($memory:expr, $data:expr, $len:expr) => {{ wasi_try_mem_ok!($data.read_utf8_string($memory, $len)) }};
 }
 
 #[allow(unused_macros)]
 macro_rules! get_input_str_bus {
-    ($memory:expr, $data:expr, $len:expr) => {{
-        wasi_try_mem_bus!($data.read_utf8_string($memory, $len))
-    }};
+    ($memory:expr, $data:expr, $len:expr) => {{ wasi_try_mem_bus!($data.read_utf8_string($memory, $len)) }};
 }
 
 #[allow(unused_macros)]
 macro_rules! get_input_str_bus_ok {
-    ($memory:expr, $data:expr, $len:expr) => {{
-        wasi_try_mem_bus_ok!($data.read_utf8_string($memory, $len))
-    }};
+    ($memory:expr, $data:expr, $len:expr) => {{ 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..a75e31be8e 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,
 };
@@ -9,9 +9,9 @@ use wasmer::{MemoryView, WasmPtr};
 use wasmer_types::MemorySize;
 use wasmer_wasix_types::{
     types::{
-        OptionTag, OptionTimestamp, Route, __wasi_addr_ip4_t, __wasi_addr_ip6_t,
-        __wasi_addr_port_t, __wasi_addr_port_u, __wasi_addr_t, __wasi_addr_u, __wasi_cidr_t,
-        __wasi_cidr_u,
+        __wasi_addr_ip4_t, __wasi_addr_ip6_t, __wasi_addr_port_t, __wasi_addr_port_u,
+        __wasi_addr_t, __wasi_addr_u, __wasi_cidr_t, __wasi_cidr_u, OptionTag, OptionTimestamp,
+        Route,
     },
     wasi::{Addressfamily, Errno},
 };
@@ -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),
@@ -274,10 +274,12 @@ pub(crate) fn read_route<M: MemorySize>(
         preferred_until: match route.preferred_until.tag {
             OptionTag::None => None,
             OptionTag::Some => Some(Duration::from_nanos(route.preferred_until.u)),
+            _ => return Err(Errno::Inval),
         },
         expires_at: match route.expires_at.tag {
             OptionTag::None => None,
             OptionTag::Some => Some(Duration::from_nanos(route.expires_at.u)),
+            _ => return Err(Errno::Inval),
         },
     })
 }
diff --git a/lib/wasix/src/net/socket.rs b/lib/wasix/src/net/socket.rs
index 73832318ee..c040b4c53b 100644
--- a/lib/wasix/src/net/socket.rs
+++ b/lib/wasix/src/net/socket.rs
@@ -4,23 +4,22 @@ 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;
 use virtual_net::{
-    net_error_into_io_err, NetworkError, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket,
-    VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+    NetworkError, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket, VirtualTcpListener,
+    VirtualTcpSocket, VirtualUdpSocket, net_error_into_io_err,
 };
 use wasmer_types::MemorySize;
 use wasmer_wasix_types::wasi::{Addressfamily, Errno, Rights, SockProto, Sockoption, Socktype};
 
-use crate::{net::net_error_into_wasi_err, VirtualTaskManager};
+use crate::{VirtualTaskManager, net::net_error_into_wasi_err};
 
 #[derive(Debug)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
@@ -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>>,
 }
 
@@ -117,37 +114,40 @@ pub enum WasiSocketOption {
     Proto,
 }
 
-impl From<Sockoption> for WasiSocketOption {
-    fn from(opt: Sockoption) -> Self {
+impl TryFrom<Sockoption> for WasiSocketOption {
+    type Error = Errno;
+
+    fn try_from(opt: Sockoption) -> Result<Self, Self::Error> {
         use WasiSocketOption::*;
         match opt {
-            Sockoption::Noop => Noop,
-            Sockoption::ReusePort => ReusePort,
-            Sockoption::ReuseAddr => ReuseAddr,
-            Sockoption::NoDelay => NoDelay,
-            Sockoption::DontRoute => DontRoute,
-            Sockoption::OnlyV6 => OnlyV6,
-            Sockoption::Broadcast => Broadcast,
-            Sockoption::MulticastLoopV4 => MulticastLoopV4,
-            Sockoption::MulticastLoopV6 => MulticastLoopV6,
-            Sockoption::Promiscuous => Promiscuous,
-            Sockoption::Listening => Listening,
-            Sockoption::LastError => LastError,
-            Sockoption::KeepAlive => KeepAlive,
-            Sockoption::Linger => Linger,
-            Sockoption::OobInline => OobInline,
-            Sockoption::RecvBufSize => RecvBufSize,
-            Sockoption::SendBufSize => SendBufSize,
-            Sockoption::RecvLowat => RecvLowat,
-            Sockoption::SendLowat => SendLowat,
-            Sockoption::RecvTimeout => RecvTimeout,
-            Sockoption::SendTimeout => SendTimeout,
-            Sockoption::ConnectTimeout => ConnectTimeout,
-            Sockoption::AcceptTimeout => AcceptTimeout,
-            Sockoption::Ttl => Ttl,
-            Sockoption::MulticastTtlV4 => MulticastTtlV4,
-            Sockoption::Type => Type,
-            Sockoption::Proto => Proto,
+            Sockoption::Noop => Ok(Noop),
+            Sockoption::ReusePort => Ok(ReusePort),
+            Sockoption::ReuseAddr => Ok(ReuseAddr),
+            Sockoption::NoDelay => Ok(NoDelay),
+            Sockoption::DontRoute => Ok(DontRoute),
+            Sockoption::OnlyV6 => Ok(OnlyV6),
+            Sockoption::Broadcast => Ok(Broadcast),
+            Sockoption::MulticastLoopV4 => Ok(MulticastLoopV4),
+            Sockoption::MulticastLoopV6 => Ok(MulticastLoopV6),
+            Sockoption::Promiscuous => Ok(Promiscuous),
+            Sockoption::Listening => Ok(Listening),
+            Sockoption::LastError => Ok(LastError),
+            Sockoption::KeepAlive => Ok(KeepAlive),
+            Sockoption::Linger => Ok(Linger),
+            Sockoption::OobInline => Ok(OobInline),
+            Sockoption::RecvBufSize => Ok(RecvBufSize),
+            Sockoption::SendBufSize => Ok(SendBufSize),
+            Sockoption::RecvLowat => Ok(RecvLowat),
+            Sockoption::SendLowat => Ok(SendLowat),
+            Sockoption::RecvTimeout => Ok(RecvTimeout),
+            Sockoption::SendTimeout => Ok(SendTimeout),
+            Sockoption::ConnectTimeout => Ok(ConnectTimeout),
+            Sockoption::AcceptTimeout => Ok(AcceptTimeout),
+            Sockoption::Ttl => Ok(Ttl),
+            Sockoption::MulticastTtlV4 => Ok(MulticastTtlV4),
+            Sockoption::Type => Ok(Type),
+            Sockoption::Proto => Ok(Proto),
+            _ => Err(Errno::Inval),
         }
     }
 }
@@ -236,6 +236,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 +276,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 +326,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 +371,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 +381,8 @@ impl InodeSocket {
             }
         };
 
+        drop(inner);
+
         tokio::select! {
             socket = socket => {
                 let socket = socket.map_err(net_error_into_wasi_err)?;
@@ -459,7 +499,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 +507,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 +1121,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 +1129,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>,
@@ -1108,13 +1148,13 @@ impl InodeSocket {
                             }
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         InodeSocketKind::RemoteSocket { is_dead, .. } => {
                             return match is_dead {
                                 true => Poll::Ready(Err(Errno::Connreset)),
                                 false => Poll::Ready(Ok(self.data.len())),
-                            }
+                            };
                         }
                         _ => return Poll::Ready(Err(Errno::Notsup)),
                     };
@@ -1169,7 +1209,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 +1217,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>,
@@ -1191,7 +1231,7 @@ impl InodeSocket {
                             socket.try_send_to(self.data, self.addr)
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         InodeSocketKind::RemoteSocket { is_dead, .. } => {
                             return match is_dead {
@@ -1244,14 +1284,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 +1301,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),
                                 }
@@ -1291,7 +1336,7 @@ impl InodeSocket {
                             };
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         _ => return Poll::Ready(Err(Errno::Notsup)),
                     };
@@ -1320,6 +1365,7 @@ impl InodeSocket {
             inner: &self.inner,
             data: buf,
             nonblocking,
+            peek,
             handler_registered: false,
         };
         if let Some(timeout) = timeout {
@@ -1338,14 +1384,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 +1401,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, ..
@@ -1375,7 +1424,7 @@ impl InodeSocket {
                             };
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         _ => return Poll::Ready(Err(Errno::Notsup)),
                     };
@@ -1402,6 +1451,7 @@ impl InodeSocket {
             inner: &self.inner,
             data: buf,
             nonblocking,
+            peek,
             handler_registered: false,
         };
         if let Some(timeout) = timeout {
@@ -1511,19 +1561,6 @@ impl InodeSocketProtected {
     }
 }
 
-#[derive(Default)]
-struct IndefinitePoll {}
-
-impl Future for IndefinitePoll {
-    type Output = ();
-    fn poll(
-        self: Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Self::Output> {
-        std::task::Poll::Pending
-    }
-}
-
 // TODO: review allow...
 #[allow(dead_code)]
 pub(crate) fn all_socket_rights() -> Rights {
diff --git a/lib/wasix/src/os/command/builtins/cmd_wasmer.rs b/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
index c0a0536907..4f609933a3 100644
--- a/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
+++ b/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
@@ -1,17 +1,22 @@
-use std::{any::Any, sync::Arc};
+use std::{any::Any, path::PathBuf, sync::Arc};
 
 use crate::{
-    os::task::{OwnedTaskStatus, TaskJoinHandle},
-    runtime::task_manager::InlineWaker,
     SpawnError,
+    bin_factory::spawn_exec_wasm,
+    os::task::{OwnedTaskStatus, TaskJoinHandle},
+    runtime::module_cache::HashedModuleData,
 };
-use wasmer::{FunctionEnvMut, Store};
+use shared_buffer::OwnedBuffer;
+use virtual_fs::{AsyncReadExt, FileSystem};
+use virtual_mio::block_on;
+use wasmer::FunctionEnvMut;
+use wasmer_package::utils::from_bytes;
 use wasmer_wasix_types::wasi::Errno;
 
 use crate::{
-    bin_factory::{spawn_exec, BinaryPackage},
-    syscalls::stderr_write,
     Runtime, WasiEnv,
+    bin_factory::{BinaryPackage, spawn_exec},
+    syscalls::stderr_write,
 };
 
 const HELP: &str = r#"USAGE:
@@ -47,12 +52,17 @@ impl CmdWasmer {
     }
 }
 
+#[derive(Debug, Clone)]
+enum Executable {
+    Wasm(OwnedBuffer),
+    BinaryPackage(Box<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 +73,82 @@ 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();
 
-                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Noent.into()).handle();
-                Ok(handle)
+                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 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(Box::new(pkg))
+                } else {
+                    Executable::Wasm(OwnedBuffer::from_bytes(bytes))
+                }
+            } else if let Ok(pkg) = self.get_package(&what).await {
+                Executable::BinaryPackage(Box::new(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 +186,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 +201,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,11 +214,11 @@ 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
                 }
             }
         };
 
-        InlineWaker::block_on(fut)
+        block_on(fut)
     }
 }
diff --git a/lib/wasix/src/os/command/mod.rs b/lib/wasix/src/os/command/mod.rs
index d5ecc590b9..e8dc55f737 100644
--- a/lib/wasix/src/os/command/mod.rs
+++ b/lib/wasix/src/os/command/mod.rs
@@ -2,12 +2,11 @@ pub mod builtins;
 
 use std::{collections::HashMap, sync::Arc};
 
-use wasmer::{FunctionEnvMut, Store};
+use virtual_mio::block_on;
+use wasmer::FunctionEnvMut;
 use wasmer_wasix_types::wasi::Errno;
 
-use crate::{
-    runtime::task_manager::InlineWaker, syscalls::stderr_write, Runtime, SpawnError, WasiEnv,
-};
+use crate::{Runtime, SpawnError, WasiEnv, syscalls::stderr_write};
 
 use super::task::{OwnedTaskStatus, TaskJoinHandle, TaskStatus};
 
@@ -19,7 +18,7 @@ where
     /// Returns the canonical name of the command.
     fn name(&self) -> &str;
 
-    /// Retrieve the command as as a [`std::any::Any`] reference.
+    /// Retrieve the command as a [`std::any::Any`] reference.
     fn as_any(&self) -> &dyn std::any::Any;
 
     /// Executes the command.
@@ -27,7 +26,6 @@ where
         &self,
         parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
         path: &str,
-        store: &mut Option<Store>,
         config: &mut Option<WasiEnv>,
     ) -> Result<TaskJoinHandle, SpawnError>;
 }
@@ -86,17 +84,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(
+                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..1a6a645ad9 100644
--- a/lib/wasix/src/os/console/mod.rs
+++ b/lib/wasix/src/os/console/mod.rs
@@ -9,18 +9,19 @@ use std::{
     io::Write,
     ops::{Deref, DerefMut},
     path::{Path, PathBuf},
-    sync::{atomic::AtomicBool, Arc, Mutex},
+    sync::{Arc, Mutex, atomic::AtomicBool},
 };
 
-use derivative::*;
+use futures::future::Either;
 use linked_hash_set::LinkedHashSet;
-use tokio::sync::{mpsc, RwLock};
+use tokio::sync::{RwLock, mpsc};
 #[allow(unused_imports, dead_code)]
 use tracing::{debug, error, info, trace, warn};
 use virtual_fs::{
     ArcBoxFile, ArcFile, AsyncWriteExt, CombineFile, DeviceFile, DuplexPipe, FileSystem, Pipe,
     PipeRx, PipeTx, RootFileSystemBuilder, StaticFile, VirtualFile,
 };
+use virtual_mio::block_on;
 #[cfg(feature = "sys")]
 use wasmer::Engine;
 use wasmer_config::package::PackageSource;
@@ -28,15 +29,14 @@ use wasmer_wasix_types::{types::__WASI_STDIN_FILENO, wasi::Errno};
 
 use super::{cconst::ConsoleConst, common::*, task::TaskJoinHandle};
 use crate::{
-    bin_factory::{spawn_exec, BinFactory, BinaryPackage},
+    Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError,
+    bin_factory::{BinFactory, BinaryPackage, spawn_exec},
     capabilities::Capabilities,
     os::task::{control_plane::WasiControlPlane, process::WasiProcess},
-    runtime::task_manager::InlineWaker,
-    Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError,
+    runners::wasi::{PackageOrHash, RuntimeOrEngine},
 };
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct Console {
     user_agent: Option<String>,
     boot_cmd: String,
@@ -179,7 +179,7 @@ impl Console {
             }
         };
 
-        let resolved_package = InlineWaker::block_on(BinaryPackage::from_registry(
+        let resolved_package = block_on(BinaryPackage::from_registry(
             &webc_ident,
             self.runtime.as_ref(),
         ));
@@ -188,7 +188,7 @@ impl Console {
             Ok(pkg) => pkg,
             Err(e) => {
                 let mut stderr = self.stderr.clone();
-                InlineWaker::block_on(async {
+                block_on(async {
                     let mut buffer = Vec::new();
                     writeln!(buffer, "Error: {e}").ok();
                     let mut source = e.source();
@@ -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
@@ -242,20 +242,17 @@ impl Console {
 
         // Display the welcome message
         if !self.whitelabel && !self.no_welcome {
-            InlineWaker::block_on(self.draw_welcome());
+            block_on(self.draw_welcome());
         }
 
         let wasi_process = env.process.clone();
 
         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();
+            block_on(async {
+                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);
@@ -274,14 +271,13 @@ impl Console {
                 .write(true)
                 .open(&path)
                 .map_err(|err| SpawnError::Other(err.into()))?;
-            InlineWaker::block_on(file.copy_reference(Box::new(StaticFile::new(data))))
+            block_on(file.copy_reference(Box::new(StaticFile::new(data))))
                 .map_err(|err| SpawnError::Other(err.into()))?;
         }
 
         // 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 = block_on(spawn_exec(pkg, prog, env, &self.runtime))?;
 
         // Return the process
         Ok((process, wasi_process))
@@ -315,8 +311,8 @@ mod tests {
     use std::{io::Read, sync::Arc};
 
     use crate::{
-        runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
         PluggableRuntime,
+        runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
     };
 
     /// Test that [`Console`] correctly runs a command with arguments and
@@ -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/backoff.rs b/lib/wasix/src/os/task/backoff.rs
index b5dc12b496..1590d0b701 100644
--- a/lib/wasix/src/os/task/backoff.rs
+++ b/lib/wasix/src/os/task/backoff.rs
@@ -2,8 +2,8 @@ use std::{
     collections::HashMap,
     pin::Pin,
     sync::{
-        atomic::{AtomicU32, Ordering},
         Arc,
+        atomic::{AtomicU32, Ordering},
     },
     task::{Context, Poll, Waker},
     time::Duration,
@@ -12,7 +12,7 @@ use std::{
 use futures::{Future, FutureExt};
 use wasmer_wasix_types::wasi::Snapshot0Clockid;
 
-use crate::{syscalls::platform_clock_time_get, VirtualTaskManager, WasiProcess};
+use crate::{VirtualTaskManager, WasiProcess, syscalls::platform_clock_time_get};
 
 use super::process::LockableWasiProcessInner;
 
@@ -90,12 +90,12 @@ impl Future for CpuBackoffToken {
 
         // Registering the waker will unregister any previous wakers
         // so that we don't go into an endless memory growth situation
-        if let Some(waker_id) = self.waker_id.take() {
-            if inner.backoff.cpu_backoff_wakers.remove(&waker_id).is_none() {
-                // if we did not remove the waker, then someone else did
-                // which means we were woken and should exit the backoff phase
-                return Poll::Ready(());
-            }
+        if let Some(waker_id) = self.waker_id.take()
+            && inner.backoff.cpu_backoff_wakers.remove(&waker_id).is_none()
+        {
+            // if we did not remove the waker, then someone else did
+            // which means we were woken and should exit the backoff phase
+            return Poll::Ready(());
         }
 
         // Register ourselves as a waker to be woken
diff --git a/lib/wasix/src/os/task/control_plane.rs b/lib/wasix/src/os/task/control_plane.rs
index 0845b075c0..18e8adab51 100644
--- a/lib/wasix/src/os/task/control_plane.rs
+++ b/lib/wasix/src/os/task/control_plane.rs
@@ -1,8 +1,8 @@
 use std::{
     collections::HashMap,
     sync::{
-        atomic::{AtomicUsize, Ordering},
         Arc, RwLock,
+        atomic::{AtomicUsize, Ordering},
     },
     time::Duration,
 };
@@ -119,11 +119,11 @@ impl WasiControlPlane {
     // Currently just increments the task counter.
     pub(crate) fn register_task(&self) -> Result<TaskCountGuard, ControlPlaneError> {
         let count = self.state.task_count.fetch_add(1, Ordering::SeqCst);
-        if let Some(max) = self.state.config.max_task_count {
-            if count > max {
-                self.state.task_count.fetch_sub(1, Ordering::SeqCst);
-                return Err(ControlPlaneError::TaskLimitReached { max: count });
-            }
+        if let Some(max) = self.state.config.max_task_count
+            && count > max
+        {
+            self.state.task_count.fetch_sub(1, Ordering::SeqCst);
+            return Err(ControlPlaneError::TaskLimitReached { max: count });
         }
         Ok(TaskCountGuard(self.state.task_count.clone()))
     }
@@ -132,12 +132,12 @@ impl WasiControlPlane {
     // FIXME: De-register terminated processes!
     // Currently they just accumulate.
     pub fn new_process(&self, module_hash: ModuleHash) -> Result<WasiProcess, ControlPlaneError> {
-        if let Some(max) = self.state.config.max_task_count {
-            if self.active_task_count() >= max {
-                // NOTE: task count is not incremented here, only when new threads are spawned.
-                // A process will always have a main thread.
-                return Err(ControlPlaneError::TaskLimitReached { max });
-            }
+        if let Some(max) = self.state.config.max_task_count
+            && self.active_task_count() >= max
+        {
+            // NOTE: task count is not incremented here, only when new threads are spawned.
+            // A process will always have a main thread.
+            return Err(ControlPlaneError::TaskLimitReached { max });
         }
 
         // Create the process first to do all the allocations before locking.
@@ -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..6ca980c80d 100644
--- a/lib/wasix/src/os/task/process.rs
+++ b/lib/wasix/src/os/task/process.rs
@@ -1,6 +1,6 @@
+use crate::{WasiEnv, WasiRuntimeError, journal::SnapshotTrigger};
 #[cfg(feature = "journal")]
-use crate::{journal::JournalEffector, syscalls::do_checkpoint_from_outside, unwind, WasiResult};
-use crate::{journal::SnapshotTrigger, WasiEnv, WasiRuntimeError};
+use crate::{WasiResult, journal::JournalEffector, syscalls::do_checkpoint_from_outside, unwind};
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "journal")]
 use std::collections::HashSet;
@@ -9,8 +9,8 @@ use std::{
     convert::TryInto,
     ops::Range,
     sync::{
-        atomic::{AtomicU32, Ordering},
         Arc, Condvar, Mutex, MutexGuard, RwLock, Weak,
+        atomic::{AtomicU32, Ordering},
     },
     task::Waker,
     time::Duration,
@@ -25,17 +25,17 @@ use wasmer_wasix_types::{
 };
 
 use crate::{
-    os::task::signal::WasiSignalInterval, syscalls::platform_clock_time_get, WasiThread,
-    WasiThreadHandle, WasiThreadId,
+    WasiThread, WasiThreadHandle, WasiThreadId, os::task::signal::WasiSignalInterval,
+    syscalls::platform_clock_time_get,
 };
 
 use super::{
+    TaskStatus,
     backoff::WasiProcessCpuBackoff,
     control_plane::{ControlPlaneError, WasiControlPlaneHandle},
     signal::{SignalDeliveryError, SignalHandlerAbi},
     task_join_handle::OwnedTaskStatus,
     thread::WasiMemoryLayout,
-    TaskStatus,
 };
 
 /// Represents the ID of a sub-process
@@ -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>,
@@ -226,7 +229,7 @@ impl WasiProcessInner {
         use wasmer::AsStoreMut;
         use wasmer_types::OnCalledAction;
 
-        use crate::{os::task::thread::RewindResultType, rewind_ext, WasiError};
+        use crate::{WasiError, os::task::thread::RewindResultType, rewind_ext};
         let guard = inner.0.lock().unwrap();
         if guard.checkpoint == WasiProcessCheckpoint::Execute {
             // No checkpoint so just carry on
@@ -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/task_join_handle.rs b/lib/wasix/src/os/task/task_join_handle.rs
index 5c2329e7f4..d503817b95 100644
--- a/lib/wasix/src/os/task/task_join_handle.rs
+++ b/lib/wasix/src/os/task/task_join_handle.rs
@@ -8,7 +8,7 @@ use wasmer_wasix_types::wasi::{Errno, ExitCode};
 
 use crate::WasiRuntimeError;
 
-use super::signal::{default_signal_handler, DynSignalHandlerAbi};
+use super::signal::{DynSignalHandlerAbi, default_signal_handler};
 
 #[derive(Clone, Debug)]
 pub enum TaskStatus {
diff --git a/lib/wasix/src/os/task/thread.rs b/lib/wasix/src/os/task/thread.rs
index 6724634940..5b25363e26 100644
--- a/lib/wasix/src/os/task/thread.rs
+++ b/lib/wasix/src/os/task/thread.rs
@@ -1,3 +1,14 @@
+use super::{
+    control_plane::TaskCountGuard,
+    task_join_handle::{OwnedTaskStatus, TaskJoinHandle},
+};
+use crate::{
+    WasiRuntimeError,
+    os::task::process::{WasiProcessId, WasiProcessInner},
+    state::LinkError,
+    syscalls::HandleRewindType,
+};
+use bytes::{Bytes, BytesMut};
 use serde::{Deserialize, Serialize};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::{
@@ -6,8 +17,6 @@ use std::{
     sync::{Arc, Condvar, Mutex, Weak},
     task::Waker,
 };
-
-use bytes::{Bytes, BytesMut};
 use wasmer::{ExportError, InstantiationError, MemoryError};
 use wasmer_wasix_types::{
     types::Signal,
@@ -15,17 +24,6 @@ use wasmer_wasix_types::{
     wasix::ThreadStartType,
 };
 
-use crate::{
-    os::task::process::{WasiProcessId, WasiProcessInner},
-    syscalls::HandleRewindType,
-    WasiRuntimeError,
-};
-
-use super::{
-    control_plane::TaskCountGuard,
-    task_join_handle::{OwnedTaskStatus, TaskJoinHandle},
-};
-
 /// Represents the ID of a WASI thread
 #[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 pub struct WasiThreadId(u32);
@@ -318,6 +316,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 +371,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 +402,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();
@@ -461,15 +467,15 @@ impl WasiThread {
 
                 // Output debug info for the dead stack
                 let mut disown = Some(Box::new(new_stack));
-                if let Some(disown) = disown.as_ref() {
-                    if !disown.snapshots.is_empty() {
-                        tracing::trace!(
-                            "wasi[{}]::stacks forgotten (memory_stack_before={}, memory_stack_after={})",
-                            self.pid(),
-                            memory_stack_before,
-                            memory_stack_after
-                        );
-                    }
+                if let Some(disown) = disown.as_ref()
+                    && !disown.snapshots.is_empty()
+                {
+                    tracing::trace!(
+                        "wasi[{}]::stacks forgotten (memory_stack_before={}, memory_stack_after={})",
+                        self.pid(),
+                        memory_stack_before,
+                        memory_stack_after
+                    );
                 }
                 let mut total_forgotten = 0usize;
                 while let Some(disowned) = disown {
@@ -617,7 +623,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 +642,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..6fba0b10c0 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>,
@@ -186,11 +184,12 @@ impl Tty {
                     if self.is_mobile {
                         let now = platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000)
                             .unwrap() as u128;
-                        if let Some((what, when)) = self.last.as_ref() {
-                            if what.as_str() == data && now - *when < TTY_MOBILE_PAUSE {
-                                self.last = None;
-                                return self;
-                            }
+                        if let Some((what, when)) = self.last.as_ref()
+                            && what.as_str() == data
+                            && now - *when < TTY_MOBILE_PAUSE
+                        {
+                            self.last = None;
+                            return self;
                         }
                         self.last = Some((data.clone(), now))
                     }
@@ -444,7 +443,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..6c73c9dadb 100644
--- a/lib/wasix/src/os/tty/tty_sys.rs
+++ b/lib/wasix/src/os/tty/tty_sys.rs
@@ -72,14 +72,13 @@ 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,
-            IGNCR, ISIG, IXON, ONLCR, OPOST, TCSANOW,
+            ECHO, ECHOCTL, ECHOE, ECHOK, ECHONL, ICANON, ICRNL, IEXTEN, IGNCR, ISIG, IXON, ONLCR,
+            OPOST, TCSANOW, c_int, tcsetattr, termios,
         },
         std::mem,
         std::os::unix::io::AsRawFd,
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..9bcca054de 100644
--- a/lib/wasix/src/runners/dcgi/factory.rs
+++ b/lib/wasix/src/runners/dcgi/factory.rs
@@ -1,13 +1,12 @@
 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};
 
 use crate::{
+    WasiStateCreationError,
     runners::wcgi::{CreateEnvConfig, CreateEnvResult, RecycleEnvConfig},
     state::conv_env_vars,
-    WasiStateCreationError,
 };
 
 use super::*;
@@ -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..c73d7f3d92 100644
--- a/lib/wasix/src/runners/dcgi/runner.rs
+++ b/lib/wasix/src/runners/dcgi/runner.rs
@@ -6,16 +6,16 @@ use wcgi_host::CgiDialect;
 use webc::metadata::Command;
 
 use crate::{
+    Runtime,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
     journal::DynJournal,
     runners::{
+        MappedDirectory,
         dcgi::handler::Handler,
         wcgi::{self, NoOpWcgiCallbacks, WcgiRunner},
-        MappedDirectory,
     },
     runtime::{DynRuntime, OverriddenRuntime},
-    Runtime,
 };
 
 use super::{DcgiCallbacks, DcgiInstanceFactory};
@@ -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..2f90fdc1fc 100644
--- a/lib/wasix/src/runners/dproxy/handler.rs
+++ b/lib/wasix/src/runners/dproxy/handler.rs
@@ -8,18 +8,16 @@ use http_body_util::BodyExt;
 use tower::Service;
 
 use super::super::Body;
-use crate::runners::dproxy::shard::Shard;
 use crate::Runtime;
+use crate::runners::dproxy::shard::Shard;
 
-use super::factory::DProxyInstanceFactory;
 use super::Config;
+use super::factory::DProxyInstanceFactory;
 
-#[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..0bcd4868fd 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},
@@ -6,9 +7,9 @@ use std::{
 };
 
 use virtual_net::{
-    host::LocalNetworking, loopback::LoopbackNetworking, IpCidr, IpRoute, NetworkError,
-    StreamSecurity, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket, VirtualTcpListener,
-    VirtualTcpSocket, VirtualUdpSocket,
+    IpCidr, IpRoute, NetworkError, StreamSecurity, VirtualIcmpSocket, VirtualNetworking,
+    VirtualRawSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+    host::LocalNetworking, loopback::LoopbackNetworking,
 };
 
 #[derive(Debug, Default)]
@@ -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..da58c621b1 100644
--- a/lib/wasix/src/runners/dproxy/runner.rs
+++ b/lib/wasix/src/runners/dproxy/runner.rs
@@ -1,7 +1,7 @@
 use std::{net::SocketAddr, sync::Arc, time::Duration};
 
 use anyhow::{Context, Error};
-use futures::{stream::FuturesUnordered, StreamExt};
+use futures::{StreamExt, stream::FuturesUnordered};
 use http::Request;
 use tower::ServiceBuilder;
 use tower_http::{catch_panic::CatchPanicLayer, cors::CorsLayer, trace::TraceLayer};
@@ -10,7 +10,7 @@ use webc::metadata::Command;
 use crate::{
     bin_factory::BinaryPackage,
     runners::wasi::WasiRunner,
-    runtime::{task_manager::VirtualTaskManagerExt, DynRuntime},
+    runtime::{DynRuntime, task_manager::VirtualTaskManagerExt},
 };
 
 use super::factory::DProxyInstanceFactory;
@@ -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..6cd2bf5cab 100644
--- a/lib/wasix/src/runners/dproxy/socket_manager.rs
+++ b/lib/wasix/src/runners/dproxy/socket_manager.rs
@@ -2,24 +2,22 @@ use std::{
     future::poll_fn,
     net::{IpAddr, Ipv4Addr, SocketAddr},
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     task::{Context, Poll},
     time::Duration,
 };
 
-use derivative::Derivative;
 use tokio::sync::broadcast;
-use virtual_net::{tcp_pair::TcpSocketHalf, LoopbackNetworking};
+use virtual_net::{LoopbackNetworking, tcp_pair::TcpSocketHalf};
 
 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..68c59b6e5d 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")]
@@ -13,7 +11,7 @@ pub mod wcgi;
 
 #[cfg(any(feature = "webc_runner_rt_wcgi", feature = "webc_runner_rt_dproxy"))]
 mod body {
-    use http_body_util::{combinators::BoxBody, BodyExt, Full};
+    use http_body_util::{BodyExt, Full, combinators::BoxBody};
 
     pub type Body = BoxBody<bytes::Bytes, anyhow::Error>;
 
@@ -38,7 +36,7 @@ pub use self::body::*;
 pub use self::{
     runner::Runner,
     wasi_common::{
-        MappedCommand, MappedDirectory, MountedDirectory, MAPPED_CURRENT_DIR_DEFAULT_PATH,
+        MAPPED_CURRENT_DIR_DEFAULT_PATH, MappedCommand, MappedDirectory, MountedDirectory,
     },
 };
 
@@ -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/runner.rs b/lib/wasix/src/runners/runner.rs
index 2504501f0f..6c8ed7ff2a 100644
--- a/lib/wasix/src/runners/runner.rs
+++ b/lib/wasix/src/runners/runner.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use anyhow::Error;
 use webc::metadata::Command;
 
-use crate::{bin_factory::BinaryPackage, Runtime};
+use crate::{Runtime, bin_factory::BinaryPackage};
 
 /// Trait that all runners have to implement
 pub trait Runner {
diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs
index 7713b80f6d..a41496d4d2 100644
--- a/lib/wasix/src/runners/wasi.rs
+++ b/lib/wasix/src/runners/wasi.rs
@@ -5,20 +5,20 @@ 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 webc::metadata::{annotations::Wasi, Command};
+use wasmer::{Engine, Module};
+use wasmer_types::ModuleHash;
+use webc::metadata::{Command, annotations::Wasi};
 
 use crate::{
+    Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
-    journal::{DynJournal, SnapshotTrigger},
-    runners::{wasi_common::CommonWasiOptions, MappedDirectory, MountedDirectory},
+    journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
+    runners::{MappedDirectory, MountedDirectory, wasi_common::CommonWasiOptions},
     runtime::task_manager::VirtualTaskManagerExt,
-    Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
 };
-use wasmer_types::ModuleHash;
 
-use super::wasi_common::{MappedCommand, MAPPED_CURRENT_DIR_DEFAULT_PATH};
+use super::wasi_common::{MAPPED_CURRENT_DIR_DEFAULT_PATH, MappedCommand};
 
 #[derive(Debug, Default, Clone)]
 pub struct WasiRunner {
@@ -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()
@@ -85,11 +109,6 @@ impl WasiRunner {
         self
     }
 
-    pub fn with_tmp_mapped(&mut self, is_tmp_mapped: bool) -> &mut Self {
-        self.wasi.is_tmp_mapped = is_tmp_mapped;
-        self
-    }
-
     pub fn with_mounted_directories<I, D>(&mut self, dirs: I) -> &mut Self
     where
         I: IntoIterator<Item = D>,
@@ -155,11 +174,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 +190,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)
+        self.wasi.snapshot_on.contains(&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 +204,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 +242,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 +271,47 @@ 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());
+
+                pkg.webc_fs.as_deref().map(|fs| fs.duplicate())
+            }
+            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 +325,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 +356,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);
             }
-            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+            for journal in self.wasi.writable_journals.iter().cloned() {
+                builder.add_writable_journal(journal);
+            }
+
+            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 +438,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,42 +515,9 @@ 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
-                                    )))
+                                    WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!("{msg}")))
                                 })
                         })
                     })
@@ -436,6 +534,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 +589,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..2dd326a0a5 100644
--- a/lib/wasix/src/runners/wasi_common.rs
+++ b/lib/wasix/src/runners/wasi_common.rs
@@ -5,18 +5,18 @@ 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 virtual_fs::{
+    FileSystem, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem, UnionFileSystem,
+};
 use webc::metadata::annotations::Wasi as WasiAnnotation;
 
 use crate::{
+    WasiEnvBuilder,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
-    journal::{DynJournal, SnapshotTrigger},
-    WasiEnvBuilder,
+    fs::{WasiFsRoot, relative_path_hack::RelativeOrAbsolutePathHack},
+    journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
 };
 
 pub const MAPPED_CURRENT_DIR_DEFAULT_PATH: &str = "/home";
@@ -29,49 +29,58 @@ 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,
     pub(crate) mapped_host_commands: Vec<MappedCommand>,
     pub(crate) mounts: Vec<MountedDirectory>,
     pub(crate) is_home_mapped: bool,
-    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 {
     pub(crate) fn prepare_webc_env(
         &self,
         builder: &mut WasiEnvBuilder,
-        container_fs: Option<Arc<dyn FileSystem + Send + Sync>>,
+        container_fs: Option<UnionFileSystem>,
         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)
-                .build()
+            let mapped_dirs = self
+                .mounts
+                .iter()
+                .map(|d| d.guest.as_str())
+                .collect::<Vec<_>>();
+            RootFileSystemBuilder::default().build_ext(&mapped_dirs)
         });
         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.set_fs(Box::new(fs));
+        builder.add_preopen_dir("/")?;
+
+        builder.set_fs_root(fs);
 
         for pkg in &self.injected_packages {
             builder.add_webc(pkg.clone());
@@ -88,7 +97,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(())
     }
@@ -177,8 +201,8 @@ fn build_directory_mappings(
 fn prepare_filesystem(
     mut root_fs: TmpFileSystem,
     mounted_dirs: &[MountedDirectory],
-    container_fs: Option<Arc<dyn FileSystem + Send + Sync>>,
-) -> Result<Box<dyn FileSystem + Send + Sync>, Error> {
+    container_fs: Option<UnionFileSystem>,
+) -> Result<WasiFsRoot, Error> {
     if !mounted_dirs.is_empty() {
         build_directory_mappings(&mut root_fs, mounted_dirs)?;
     }
@@ -195,10 +219,9 @@ fn prepare_filesystem(
     let fs = if let Some(container) = container_fs {
         let container = RelativeOrAbsolutePathHack(container);
         let fs = OverlayFileSystem::new(root_fs, [container]);
-        Box::new(fs) as Box<dyn FileSystem + Send + Sync>
+        WasiFsRoot::Overlay(Arc::new(fs))
     } else {
-        let fs = RelativeOrAbsolutePathHack(root_fs);
-        Box::new(fs) as Box<dyn FileSystem + Send + Sync>
+        WasiFsRoot::Sandbox(root_fs)
     };
 
     Ok(fs)
@@ -287,100 +310,12 @@ impl From<MappedDirectory> for MountedDirectory {
     }
 }
 
-#[derive(Debug)]
-struct RelativeOrAbsolutePathHack<F>(F);
-
-impl<F: FileSystem> RelativeOrAbsolutePathHack<F> {
-    fn execute<Func, Ret>(&self, path: &Path, operation: Func) -> Result<Ret, FsError>
-    where
-        Func: Fn(&F, &Path) -> Result<Ret, FsError>,
-    {
-        // First, try it with the path we were given
-        let result = operation(&self.0, path);
-
-        if result.is_err() && !path.is_absolute() {
-            // we were given a relative path, but maybe the operation will work
-            // using absolute paths instead.
-            let path = Path::new("/").join(path);
-            operation(&self.0, &path)
-        } else {
-            result
-        }
-    }
-}
-
-impl<F: FileSystem> virtual_fs::FileSystem for RelativeOrAbsolutePathHack<F> {
-    fn readlink(&self, path: &Path) -> virtual_fs::Result<PathBuf> {
-        self.execute(path, |fs, p| fs.readlink(p))
-    }
-
-    fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
-        self.execute(path, |fs, p| fs.read_dir(p))
-    }
-
-    fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
-        self.execute(path, |fs, p| fs.create_dir(p))
-    }
-
-    fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
-        self.execute(path, |fs, p| fs.remove_dir(p))
-    }
-
-    fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
-        let from = from.to_owned();
-        let to = to.to_owned();
-        Box::pin(async move { self.0.rename(&from, &to).await })
-    }
-
-    fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
-        self.execute(path, |fs, p| fs.metadata(p))
-    }
-
-    fn symlink_metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
-        self.execute(path, |fs, p| fs.symlink_metadata(p))
-    }
-
-    fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
-        self.execute(path, |fs, p| fs.remove_file(p))
-    }
-
-    fn new_open_options(&self) -> virtual_fs::OpenOptions {
-        virtual_fs::OpenOptions::new(self)
-    }
-
-    fn mount(
-        &self,
-        name: String,
-        path: &Path,
-        fs: Box<dyn FileSystem + Send + Sync>,
-    ) -> virtual_fs::Result<()> {
-        let name_ref = &name;
-        let f_ref = &Arc::new(fs);
-        self.execute(path, move |f, p| {
-            f.mount(name_ref.clone(), p, Box::new(f_ref.clone()))
-        })
-    }
-}
-
-impl<F: FileSystem> virtual_fs::FileOpener for RelativeOrAbsolutePathHack<F> {
-    fn open(
-        &self,
-        path: &Path,
-        conf: &virtual_fs::OpenOptionsConfig,
-    ) -> virtual_fs::Result<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>> {
-        self.execute(path, |fs, p| {
-            fs.new_open_options().options(conf.clone()).open(p)
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::time::SystemTime;
 
     use tempfile::TempDir;
-    use virtual_fs::{DirEntry, FileType, Metadata, WebcVolumeFileSystem};
-    use webc::Container;
+    use virtual_fs::{DirEntry, FileType, Metadata};
 
     use super::*;
 
@@ -394,7 +329,6 @@ mod tests {
             ..Default::default()
         };
         let mut builder = WasiEnvBuilder::new("program-name");
-        let fs = Arc::new(virtual_fs::EmptyFileSystem::default());
         let mut annotations = WasiAnnotation::new("some-atom");
         annotations.main_args = Some(vec![
             "hard".to_string(),
@@ -402,7 +336,7 @@ mod tests {
             "args".to_string(),
         ]);
 
-        args.prepare_webc_env(&mut builder, Some(fs), &annotations, None)
+        args.prepare_webc_env(&mut builder, None, &annotations, None)
             .unwrap();
 
         assert_eq!(
@@ -430,11 +364,10 @@ mod tests {
             ..Default::default()
         };
         let mut builder = WasiEnvBuilder::new("python");
-        let fs = Arc::new(virtual_fs::EmptyFileSystem::default());
         let mut annotations = WasiAnnotation::new("python");
         annotations.env = Some(vec!["HARD_CODED=env-vars".to_string()]);
 
-        args.prepare_webc_env(&mut builder, Some(fs), &annotations, None)
+        args.prepare_webc_env(&mut builder, None, &annotations, None)
             .unwrap();
 
         assert_eq!(
@@ -446,6 +379,11 @@ mod tests {
         );
     }
 
+    fn unix_timestamp_nanos(instant: SystemTime) -> Option<u64> {
+        let duration = instant.duration_since(SystemTime::UNIX_EPOCH).ok()?;
+        Some(duration.as_nanos() as u64)
+    }
+
     #[tokio::test]
     #[cfg_attr(not(feature = "host-fs"), ignore)]
     async fn python_use_case() {
@@ -457,27 +395,39 @@ mod tests {
             guest: "/home".to_string(),
             host: sub_dir,
         })];
-        let container = Container::from_bytes(PYTHON).unwrap();
-        let webc_fs = WebcVolumeFileSystem::mount_all(&container);
+        let container = wasmer_package::utils::from_bytes(PYTHON).unwrap();
+        let webc_fs = virtual_fs::WebcVolumeFileSystem::mount_all(&container);
+        let union_fs = UnionFileSystem::new();
+        union_fs
+            .mount("webc".to_string(), Path::new("/"), Box::new(webc_fs))
+            .unwrap();
 
         let root_fs = RootFileSystemBuilder::default().build();
-        let fs = prepare_filesystem(root_fs, &mapping, Some(Arc::new(webc_fs))).unwrap();
-
-        assert!(fs.metadata("/home/file.txt".as_ref()).unwrap().is_file());
-        assert!(fs.metadata("lib".as_ref()).unwrap().is_dir());
-        assert!(fs
-            .metadata("lib/python3.6/collections/__init__.py".as_ref())
-            .unwrap()
-            .is_file());
-        assert!(fs
-            .metadata("lib/python3.6/encodings/__init__.py".as_ref())
-            .unwrap()
-            .is_file());
-    }
-
-    fn unix_timestamp_nanos(instant: SystemTime) -> Option<u64> {
-        let duration = instant.duration_since(SystemTime::UNIX_EPOCH).ok()?;
-        Some(duration.as_nanos() as u64)
+        let fs = prepare_filesystem(root_fs, &mapping, Some(union_fs)).unwrap();
+
+        assert!(matches!(fs, WasiFsRoot::Overlay(_)));
+        if let WasiFsRoot::Overlay(overlay_fs) = &fs {
+            use virtual_fs::FileSystem;
+            assert!(
+                overlay_fs
+                    .metadata("/home/file.txt".as_ref())
+                    .unwrap()
+                    .is_file()
+            );
+            assert!(overlay_fs.metadata("lib".as_ref()).unwrap().is_dir());
+            assert!(
+                overlay_fs
+                    .metadata("lib/python3.6/collections/__init__.py".as_ref())
+                    .unwrap()
+                    .is_file()
+            );
+            assert!(
+                overlay_fs
+                    .metadata("lib/python3.6/encodings/__init__.py".as_ref())
+                    .unwrap()
+                    .is_file()
+            );
+        }
     }
 
     #[tokio::test]
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/create_env.rs b/lib/wasix/src/runners/wcgi/create_env.rs
index c8ab9fe9ac..31d85d560b 100644
--- a/lib/wasix/src/runners/wcgi/create_env.rs
+++ b/lib/wasix/src/runners/wcgi/create_env.rs
@@ -1,11 +1,11 @@
 use virtual_fs::Pipe;
 
 use crate::{
-    capabilities::Capabilities, http::HttpClientCapabilityV1,
-    runners::wcgi::callbacks::CreateEnvResult, WasiEnvBuilder,
+    WasiEnvBuilder, capabilities::Capabilities, http::HttpClientCapabilityV1,
+    runners::wcgi::callbacks::CreateEnvResult,
 };
 
-use super::{callbacks::CreateEnvConfig, RecycleEnvConfig};
+use super::{RecycleEnvConfig, callbacks::CreateEnvConfig};
 
 pub(crate) async fn default_recycle_env(mut conf: RecycleEnvConfig) {
     tracing::debug!("Destroying the WebAssembly instance");
diff --git a/lib/wasix/src/runners/wcgi/handler.rs b/lib/wasix/src/runners/wcgi/handler.rs
index 5d4c5b5f89..7a97f9269a 100644
--- a/lib/wasix/src/runners/wcgi/handler.rs
+++ b/lib/wasix/src/runners/wcgi/handler.rs
@@ -8,7 +8,7 @@ use http_body_util::BodyExt;
 use hyper::body::Frame;
 use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt};
 use tracing::Instrument;
-use virtual_mio::InlineWaker;
+use virtual_mio::block_on;
 use wasmer::Module;
 use wasmer_wasix_types::wasi::ExitCode;
 use wcgi_host::CgiDialect;
@@ -16,17 +16,17 @@ use wcgi_host::CgiDialect;
 use super::super::Body;
 
 use crate::{
+    Runtime, VirtualTaskManager, WasiEnvBuilder,
     bin_factory::run_exec,
     os::task::OwnedTaskStatus,
     runners::{
         body_from_data, body_from_stream,
         wcgi::{
-            callbacks::{CreateEnvConfig, RecycleEnvConfig},
             Callbacks,
+            callbacks::{CreateEnvConfig, RecycleEnvConfig},
         },
     },
     runtime::task_manager::{TaskWasm, TaskWasmRecycleProperties},
-    Runtime, VirtualTaskManager, WasiEnvBuilder,
 };
 use wasmer_types::ModuleHash;
 
@@ -91,7 +91,7 @@ impl Handler {
         let recycle = {
             let callbacks = callbacks.clone();
             move |props: TaskWasmRecycleProperties| {
-                InlineWaker::block_on(callbacks.recycle_env(RecycleEnvConfig {
+                block_on(callbacks.recycle_env(RecycleEnvConfig {
                     env: props.env,
                     store: props.store,
                     memory: props.memory,
@@ -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)),
             )
@@ -158,12 +158,12 @@ impl Handler {
         // will cause the stderr pipe to be read to the end
         // before transmitting the body
         if propagate_stderr {
-            if let Some(stderr) = work_consume_stderr.await {
-                if !stderr.is_empty() {
-                    return Ok(Response::builder()
-                        .status(StatusCode::INTERNAL_SERVER_ERROR)
-                        .body(body_from_data(stderr))?);
-                }
+            if let Some(stderr) = work_consume_stderr.await
+                && !stderr.is_empty()
+            {
+                return Ok(Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(body_from_data(stderr))?);
             }
         } else {
             task_manager
@@ -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..c698f4b1f3 100644
--- a/lib/wasix/src/runners/wcgi/runner.rs
+++ b/lib/wasix/src/runners/wcgi/runner.rs
@@ -1,27 +1,27 @@
-use std::{net::SocketAddr, sync::Arc};
+use std::{borrow::Cow, net::SocketAddr, sync::Arc};
 
 use super::super::Body;
 use anyhow::{Context, Error};
-use futures::{stream::FuturesUnordered, StreamExt};
+use futures::{StreamExt, stream::FuturesUnordered};
 use http::{Request, Response};
 use tower::ServiceBuilder;
 use tower_http::{catch_panic::CatchPanicLayer, cors::CorsLayer, trace::TraceLayer};
 use wcgi_host::CgiDialect;
 use webc::metadata::{
-    annotations::{Wasi, Wcgi},
     Command,
+    annotations::{Wasi, Wcgi},
 };
 
 use crate::{
+    Runtime, WasiEnvBuilder,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
     runners::{
+        MappedDirectory,
         wasi_common::CommonWasiOptions,
         wcgi::handler::{Handler, SharedState},
-        MappedDirectory,
     },
-    runtime::task_manager::VirtualTaskManagerExt,
-    Runtime, WasiEnvBuilder,
+    runtime::{ModuleInput, task_manager::VirtualTaskManagerExt},
 };
 
 use super::Callbacks;
@@ -62,7 +62,8 @@ impl WcgiRunner {
             .annotation("wasi")?
             .unwrap_or_else(|| Wasi::new(command_name));
 
-        let module = runtime.load_module_sync(cmd.atom())?;
+        let input = ModuleInput::Command(Cow::Borrowed(cmd));
+        let module = runtime.resolve_module_sync(input, None, None)?;
 
         let Wcgi { dialect, .. } = metadata.annotation("wcgi")?.unwrap_or_default();
         let dialect = match dialect {
@@ -70,12 +71,13 @@ impl WcgiRunner {
             None => default_dialect,
         };
 
-        let container_fs = Arc::clone(&pkg.webc_fs);
+        let container_fs = pkg.webc_fs.clone();
 
         let wasi_common = self.config.wasi.clone();
         let rt = Arc::clone(&runtime);
         let setup_builder = move |builder: &mut WasiEnvBuilder| {
-            wasi_common.prepare_webc_env(builder, Some(Arc::clone(&container_fs)), &wasi, None)?;
+            let container_fs = container_fs.as_ref().map(|x| x.duplicate());
+            wasi_common.prepare_webc_env(builder, container_fs, &wasi, None)?;
             builder.set_runtime(Arc::clone(&rt));
             Ok(())
         };
@@ -101,13 +103,13 @@ impl WcgiRunner {
     ) -> Result<(), Error>
     where
         S: tower::Service<
-            Request<hyper::body::Incoming>,
-            Response = http::Response<Body>,
-            Error = anyhow::Error,
-            Future = std::pin::Pin<
-                Box<dyn futures::Future<Output = Result<Response<Body>, Error>> + Send>,
+                Request<hyper::body::Incoming>,
+                Response = http::Response<Body>,
+                Error = anyhow::Error,
+                Future = std::pin::Pin<
+                    Box<dyn futures::Future<Output = Result<Response<Body>, Error>> + Send>,
+                >,
             >,
-        >,
         S: Clone + Send + Sync + 'static,
     {
         let service = ServiceBuilder::new()
@@ -154,7 +156,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 +195,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 +273,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
     }
@@ -314,7 +314,7 @@ impl Config {
 
     #[cfg(feature = "journal")]
     pub fn has_snapshot_trigger(&self, on: crate::journal::SnapshotTrigger) -> bool {
-        self.wasi.snapshot_on.iter().any(|t| *t == on)
+        self.wasi.snapshot_on.contains(&on)
     }
 
     #[cfg(feature = "journal")]
@@ -327,8 +327,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..f25a75b0f4 100644
--- a/lib/wasix/src/runtime/mod.rs
+++ b/lib/wasix/src/runtime/mod.rs
@@ -3,33 +3,43 @@ pub mod package_loader;
 pub mod resolver;
 pub mod task_manager;
 
-pub use self::task_manager::{SpawnMemoryType, VirtualTaskManager};
-use self::{module_cache::CacheError, task_manager::InlineWaker};
-use wasmer_types::ModuleHash;
+use self::module_cache::CacheError;
+pub use self::task_manager::{SpawnType, VirtualTaskManager};
+use module_cache::HashedModuleData;
+use wasmer_config::package::SuggestedCompilerOptimizations;
+use wasmer_types::{
+    CompilationProgressCallback, ModuleHash,
+    target::UserCompilerOptimizations as WasmerSuggestedCompilerOptimizations,
+};
 
 use std::{
+    borrow::Cow,
     fmt,
     ops::Deref,
     sync::{Arc, Mutex},
 };
 
-use derivative::Derivative;
 use futures::future::BoxFuture;
+use virtual_mio::block_on;
 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::{
+    SpawnError, WasiTtyState,
+    bin_factory::BinaryPackageCommand,
     http::{DynHttpClient, HttpClient},
     os::TtyBridge,
     runtime::{
-        module_cache::{ModuleCache, ThreadLocalCache},
+        module_cache::{
+            ModuleCache, ThreadLocalCache,
+            progress::{ModuleLoadProgress, ModuleLoadProgressReporter},
+        },
         package_loader::{PackageLoader, UnsupportedPackageLoader},
         resolver::{BackendSource, MultiSource, Source},
     },
-    SpawnError, WasiTtyState,
 };
 
 #[derive(Clone)]
@@ -37,6 +47,75 @@ pub enum TaintReason {
     UnknownWasiVersion,
     NonZeroExitCode(ExitCode),
     RuntimeError(RuntimeError),
+    DlSymbolResolutionFailed(String),
+}
+
+/// The input to load a module.
+///
+/// Exists because the semantics for resolving modules can vary between
+/// different sources.
+///
+/// All variants are wrapped in `Cow` to allow for zero-copy usage when possible.
+pub enum ModuleInput<'a> {
+    /// Raw bytes.
+    Bytes(Cow<'a, [u8]>),
+    /// Pre-hashed module data.
+    Hashed(Cow<'a, HashedModuleData>),
+    /// A binary package command.
+    Command(Cow<'a, BinaryPackageCommand>),
+}
+
+impl<'a> ModuleInput<'a> {
+    /// Convert to an owned version of the module input.
+    pub fn to_owned(&'a self) -> ModuleInput<'static> {
+        // The manual code below is needed due to compiler issues with the lifetime.
+        match self {
+            Self::Bytes(Cow::Borrowed(b)) => {
+                let v: Vec<u8> = (*b).to_owned();
+                let c: Cow<'static, [u8]> = Cow::from(v);
+                ModuleInput::Bytes(c)
+            }
+            Self::Bytes(Cow::Owned(b)) => ModuleInput::Bytes(Cow::Owned((*b).clone())),
+            Self::Hashed(Cow::Borrowed(h)) => ModuleInput::Hashed(Cow::Owned((*h).clone())),
+            Self::Hashed(Cow::Owned(h)) => ModuleInput::Hashed(Cow::Owned(h.clone())),
+            Self::Command(Cow::Borrowed(c)) => ModuleInput::Command(Cow::Owned((*c).clone())),
+            Self::Command(Cow::Owned(c)) => ModuleInput::Command(Cow::Owned(c.clone())),
+        }
+    }
+
+    /// Get the module hash.
+    ///
+    /// NOTE: may be expensive, depending on the variant.
+    pub fn hash(&self) -> ModuleHash {
+        match self {
+            Self::Bytes(b) => {
+                // Hash on the fly
+                ModuleHash::new(b)
+            }
+            Self::Hashed(hashed) => *hashed.hash(),
+            Self::Command(cmd) => *cmd.hash(),
+        }
+    }
+
+    /// Get the raw WebAssembly bytes.
+    pub fn wasm(&self) -> &[u8] {
+        match self {
+            Self::Bytes(b) => b,
+            Self::Hashed(hashed) => hashed.wasm().as_ref(),
+            Self::Command(cmd) => cmd.atom_ref().as_ref(),
+        }
+    }
+
+    /// Convert to a `HashedModuleData`.
+    ///
+    /// May involve cloning and hashing.
+    pub fn to_hashed(&self) -> HashedModuleData {
+        match self {
+            Self::Bytes(b) => HashedModuleData::new(b.as_ref()),
+            Self::Hashed(hashed) => hashed.as_ref().clone(),
+            Self::Command(cmd) => HashedModuleData::from_command(cmd),
+        }
+    }
 }
 
 /// Runtime components used when running WebAssembly programs.
@@ -73,8 +152,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 +188,132 @@ 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();
-        let module_cache = self.module_cache();
-        let hash = ModuleHash::xxhash(wasm);
+    /// The primary way to load a module given a module input.
+    ///
+    /// The engine to use can be optionally provided, otherwise the most appropriate engine
+    /// should be selected.
+    ///
+    /// An optional progress reporter callback can be provided to report progress during module loading.
+    fn resolve_module<'a>(
+        &'a self,
+        input: ModuleInput<'a>,
+        engine: Option<&Engine>,
+        on_progress: Option<ModuleLoadProgressReporter>,
+    ) -> BoxFuture<'a, Result<Module, SpawnError>> {
+        let data = input.to_hashed();
+
+        let engine = if let Some(e) = engine {
+            e.clone()
+        } else {
+            match &input {
+                ModuleInput::Bytes(_) => self.engine(),
+                ModuleInput::Hashed(_) => self.engine(),
+                ModuleInput::Command(cmd) => {
+                    match self
+                        .engine_with_suggested_opts(&cmd.as_ref().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 module_cache = self.module_cache();
 
+        let task = async move { load_module(&engine, &module_cache, input, on_progress).await };
         Box::pin(task)
     }
 
-    /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
+    /// Sync variant of [`Self::resolve_module`].
+    fn resolve_module_sync(
+        &self,
+        input: ModuleInput<'_>,
+        engine: Option<&Engine>,
+        on_progress: Option<ModuleLoadProgressReporter>,
+    ) -> Result<Module, SpawnError> {
+        block_on(self.resolve_module(input, engine, on_progress))
+    }
+
+    /// 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!
+    #[deprecated(since = "0.601.0", note = "Use `resolve_module` instead")]
+    fn load_command_module(
+        &self,
+        cmd: &BinaryPackageCommand,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        self.resolve_module(ModuleInput::Command(Cow::Owned(cmd.clone())), None, None)
+    }
+
+    /// Sync version of [`Self::load_command_module`].
+    #[deprecated(since = "0.601.0", note = "Use `resolve_module_sync` instead")]
+    fn load_command_module_sync(&self, cmd: &BinaryPackageCommand) -> Result<Module, SpawnError> {
+        block_on(self.resolve_module(ModuleInput::Command(Cow::Borrowed(cmd)), None, None))
+    }
+
+    /// 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 `resolve_module` instead")]
+    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, Result<Module, SpawnError>> {
+        self.resolve_module(ModuleInput::Bytes(Cow::Borrowed(wasm)), None, None)
+    }
+
+    /// 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> {
-        InlineWaker::block_on(self.load_module(wasm))
+        block_on(self.resolve_module(ModuleInput::Bytes(Cow::Borrowed(wasm)), None, None))
+    }
+
+    /// 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>> {
+        self.resolve_module(ModuleInput::Hashed(Cow::Owned(module)), engine, None)
+    }
+
+    /// Synchronous version of [`Self::load_hashed_module`].
+    fn load_hashed_module_sync(
+        &self,
+        wasm: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> Result<Module, SpawnError> {
+        block_on(self.resolve_module(ModuleInput::Hashed(Cow::Owned(wasm)), engine, None))
     }
 
     /// 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,21 +326,26 @@ 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,
+    input: ModuleInput<'_>,
+    on_progress: Option<ModuleLoadProgressReporter>,
 ) -> Result<Module, crate::SpawnError> {
-    let result = module_cache.load(wasm_hash, engine).await;
+    let wasm_hash = input.hash();
+
+    let result = if let Some(on_progress) = &on_progress {
+        module_cache
+            .load_with_progress(wasm_hash, engine, on_progress.clone())
+            .await
+    } else {
+        module_cache.load(wasm_hash, engine).await
+    };
 
     match result {
         Ok(module) => return Ok(module),
@@ -165,11 +359,34 @@ pub async fn load_module(
         }
     }
 
-    let module = Module::new(&engine, wasm).map_err(|err| crate::SpawnError::CompileError {
+    let res = if let Some(progress) = on_progress {
+        #[allow(unused_variables)]
+        let p = CompilationProgressCallback::new(move |p| {
+            progress.notify(ModuleLoadProgress::CompilingModule(p))
+        });
+        #[cfg(feature = "sys-default")]
+        {
+            if engine.is_sys() {
+                use wasmer::sys::NativeEngineExt;
+                engine.new_module_with_progress(input.wasm(), p)
+            } else {
+                Module::new(&engine, input.wasm())
+            }
+        }
+        #[cfg(not(feature = "sys-default"))]
+        {
+            Module::new(&engine, input.wasm())
+        }
+    } else {
+        Module::new(&engine, input.wasm())
+    };
+
+    let module = res.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 +422,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 +453,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 +465,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 +485,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 +503,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 +525,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 +554,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 +575,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 +600,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 +622,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 +656,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 +666,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 +725,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 +758,29 @@ 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 active_journal(&self) -> Option<&'_ DynJournal> {
-        if let Some(journals) = self.journals.as_ref() {
-            journals.iter().last().map(|a| a.as_ref())
+    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.active_journal()
+            self.inner.writable_journals()
         }
     }
 
-    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 };
-            Box::pin(task)
-        } else {
-            self.inner.load_module(wasm)
-        }
-    }
-
-    fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError> {
-        if self.engine.is_some() || self.module_cache.is_some() {
-            InlineWaker::block_on(self.load_module(wasm))
+    #[cfg(feature = "journal")]
+    fn active_journal(&self) -> Option<&'_ DynJournal> {
+        if let Some(journals) = self.writable_journals.as_ref() {
+            journals.iter().last().map(|a| a.as_ref())
         } else {
-            self.inner.load_module_sync(wasm)
+            self.inner.active_journal()
         }
     }
 }
diff --git a/lib/wasix/src/runtime/module_cache/fallback.rs b/lib/wasix/src/runtime/module_cache/fallback.rs
index 905643ce6c..575e565667 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,
@@ -179,7 +191,7 @@ mod tests {
     async fn load_from_primary() {
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         let primary = SharedCache::default();
         let fallback = SharedCache::default();
         primary.save(key, &engine, &module).await.unwrap();
@@ -204,7 +216,7 @@ mod tests {
     async fn loading_from_fallback_also_populates_primary() {
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         let primary = SharedCache::default();
         let fallback = SharedCache::default();
         fallback.save(key, &engine, &module).await.unwrap();
@@ -230,7 +242,7 @@ mod tests {
     async fn saving_will_update_both() {
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         let primary = SharedCache::default();
         let fallback = SharedCache::default();
         let cache = FallbackCache::new(&primary, &fallback);
diff --git a/lib/wasix/src/runtime/module_cache/filesystem.rs b/lib/wasix/src/runtime/module_cache/filesystem.rs
index 5528ff2261..675c1bfa51 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()
     }
@@ -220,8 +244,8 @@ mod tests {
         let engine = Engine::default();
         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 key = ModuleHash::from_bytes([0; _]);
+        let expected_path = cache.path(key, &engine.deterministic_id());
 
         cache.save(key, &engine, &module).await.unwrap();
 
@@ -236,7 +260,7 @@ mod tests {
         let cache_dir = temp.path().join("this").join("doesn't").join("exist");
         assert!(!cache_dir.exists());
         let cache = FileSystemCache::new(&cache_dir, create_tokio_task_manager());
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
 
         cache.save(key, &engine, &module).await.unwrap();
 
@@ -247,7 +271,7 @@ mod tests {
     async fn missing_file() {
         let temp = TempDir::new().unwrap();
         let engine = Engine::default();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
 
         let err = cache.load(key, &engine).await.unwrap_err();
@@ -260,9 +284,9 @@ mod tests {
         let temp = TempDir::new().unwrap();
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         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();
@@ -283,9 +307,9 @@ mod tests {
         let temp = TempDir::new().unwrap();
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
         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..48e91dc202
--- /dev/null
+++ b/lib/wasix/src/runtime/module_cache/hashed_module.rs
@@ -0,0 +1,52 @@
+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 [`BinaryPackageCommand`](crate::bin_factory::BinaryPackageCommand), 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 {
+        let wasm = bytes.into();
+        let hash = ModuleHash::new(&wasm);
+        Self { hash, wasm }
+    }
+
+    /// Create new [`HashedModuleData`] from the given [`BinaryPackageCommand`](crate::bin_factory::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..f9437cb489 100644
--- a/lib/wasix/src/runtime/module_cache/mod.rs
+++ b/lib/wasix/src/runtime/module_cache/mod.rs
@@ -31,15 +31,19 @@
 //! 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;
+pub mod progress;
 mod shared;
 mod thread_local;
 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/progress.rs b/lib/wasix/src/runtime/module_cache/progress.rs
new file mode 100644
index 0000000000..499035f295
--- /dev/null
+++ b/lib/wasix/src/runtime/module_cache/progress.rs
@@ -0,0 +1,110 @@
+use std::sync::Arc;
+
+use wasmer_types::UserAbort;
+
+/// Progress during module loading.
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub enum ModuleLoadProgress {
+    /// Module was found in local cache.
+    LocalCacheHit,
+    /// Module is being downloaded.
+    DownloadingModule(DownloadProgress),
+    /// Module artifact was found in local cache.
+    ArtifactCacheHit,
+    /// Module artifact is being loaded from remote source.
+    RemoteArtifact(RemoteArtifactProgress),
+    /// Module is being compiled.
+    CompilingModule(wasmer_types::CompilationProgress),
+}
+
+/// Progress during remote module artifact resolution.
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub enum RemoteArtifactProgress {
+    /// Checking remote cache for artifact.
+    RemoteCacheCheck,
+    /// Artifact found in remote cache.
+    RemoteCacheHit,
+    /// Artifact is being downloaded.
+    LoadingArtifact(DownloadProgress),
+    /// Artifact loading failed - module will be compiled locally instead.
+    ArtifactLoadFailed(ProgressError),
+}
+
+/// Generic download progress.
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub struct DownloadProgress {
+    pub total_bytes: u64,
+    pub downloaded_bytes: Option<u64>,
+}
+
+impl DownloadProgress {
+    /// Creates a new [`DownloadProgress`].
+    pub fn new(total_bytes: u64, downloaded_bytes: Option<u64>) -> Self {
+        Self {
+            total_bytes,
+            downloaded_bytes,
+        }
+    }
+}
+
+/// Error that can occur during module loading.
+#[derive(Clone, Debug)]
+pub struct ProgressError {
+    message: String,
+}
+
+impl ProgressError {
+    pub fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl std::fmt::Display for ProgressError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+/// Reports progress during module loading.
+///
+/// See [`ModuleLoadProgressReporter::new`] for details.
+#[derive(Clone)]
+pub struct ModuleLoadProgressReporter {
+    callback: Arc<dyn Fn(ModuleLoadProgress) -> Result<(), UserAbort> + Send + Sync>,
+}
+
+impl ModuleLoadProgressReporter {
+    /// Construct a new `ModuleLoadProgressReporter`.
+    ///
+    /// The callback function has the signature:
+    /// `Fn(ModuleLoadProgress) -> Result<(), UserAbort> + Send + Sync + 'static'.
+    ///
+    /// # Aborting module loading
+    ///
+    /// The callback has to return a `Result<(), UserAbort>`.
+    /// If an error is returned, the module loading process will be aborted.
+    pub fn new<F>(callback: F) -> Self
+    where
+        F: Fn(ModuleLoadProgress) -> Result<(), UserAbort> + Send + Sync + 'static,
+    {
+        Self {
+            callback: Arc::new(callback),
+        }
+    }
+
+    /// Notify the reporter about new progress information.
+    pub fn notify(&self, progress: ModuleLoadProgress) -> Result<(), UserAbort> {
+        (self.callback)(progress)
+    }
+}
+
+impl std::fmt::Debug for ModuleLoadProgressReporter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ModuleLoadProgressReporter").finish()
+    }
+}
diff --git a/lib/wasix/src/runtime/module_cache/shared.rs b/lib/wasix/src/runtime/module_cache/shared.rs
index 305e80ff65..ebc443abf2 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,
@@ -65,7 +70,7 @@ mod tests {
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
         let cache = SharedCache::default();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
 
         cache.save(key, &engine, &module).await.unwrap();
         let round_tripped = cache.load(key, &engine).await.unwrap();
diff --git a/lib/wasix/src/runtime/module_cache/thread_local.rs b/lib/wasix/src/runtime/module_cache/thread_local.rs
index c23744ae19..586bcaeff9 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(())
     }
 }
@@ -71,7 +76,7 @@ mod tests {
         let engine = Engine::default();
         let module = Module::new(&engine, ADD_WAT).unwrap();
         let cache = ThreadLocalCache::default();
-        let key = ModuleHash::xxhash_from_bytes([0; 8]);
+        let key = ModuleHash::from_bytes([0; _]);
 
         cache.save(key, &engine, &module).await.unwrap();
         let round_tripped = cache.load(key, &engine).await.unwrap();
diff --git a/lib/wasix/src/runtime/module_cache/types.rs b/lib/wasix/src/runtime/module_cache/types.rs
index 79494f0e3b..3c4510cdb9 100644
--- a/lib/wasix/src/runtime/module_cache/types.rs
+++ b/lib/wasix/src/runtime/module_cache/types.rs
@@ -3,7 +3,7 @@ use std::{fmt::Debug, ops::Deref, path::PathBuf};
 use wasmer::{Engine, Module};
 use wasmer_types::ModuleHash;
 
-use crate::runtime::module_cache::FallbackCache;
+use crate::runtime::module_cache::{FallbackCache, progress::ModuleLoadProgressReporter};
 
 /// A cache for compiled WebAssembly modules.
 ///
@@ -26,6 +26,23 @@ pub trait ModuleCache: Debug {
     /// Load a module based on its hash.
     async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError>;
 
+    /// Load a module based on its hash, with progress reporting.
+    ///
+    /// The provided progress reporter will receive updates about the loading process, if supported.
+    async fn load_with_progress(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        on_progress: ModuleLoadProgressReporter,
+    ) -> Result<Module, CacheError> {
+        // Default implementation just ignores progress reporting.
+        let _ = on_progress;
+        self.load(key, engine).await
+    }
+
+    /// 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.
     ///
@@ -48,6 +65,8 @@ pub trait ModuleCache: Debug {
     /// be significantly slower than the previous one.
     ///
     /// ```rust
+    /// # #[cfg(feature = "sys-thread")]
+    /// # {
     /// use wasmer_wasix::runtime::module_cache::{
     ///     ModuleCache, ThreadLocalCache, FileSystemCache, SharedCache,
     /// };
@@ -59,6 +78,7 @@ pub trait ModuleCache: Debug {
     ///
     /// let cache = SharedCache::default()
     ///     .with_fallback(FileSystemCache::new("~/.local/cache", task_manager));
+    /// # }
     /// ```
     fn with_fallback<C>(self, other: C) -> FallbackCache<Self, C>
     where
@@ -79,6 +99,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,
@@ -133,19 +157,29 @@ mod tests {
 
     #[test]
     fn key_is_displayed_as_hex() {
-        let key = ModuleHash::xxhash_from_bytes([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
+        let key = ModuleHash::from_bytes([
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
+            0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
+            0x1C, 0x1D, 0x1E, 0x1F,
+        ]);
 
         let repr = key.to_string();
 
-        assert_eq!(repr, "0001020304050607");
+        assert_eq!(
+            repr,
+            "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
+        );
     }
 
     #[test]
     fn module_hash_is_just_sha_256() {
         let wasm = b"\0asm...";
-        let raw = [0x0c, 0xc7, 0x88, 0x60, 0xd4, 0x14, 0x71, 0x4c];
+        let raw = [
+            90, 57, 254, 239, 82, 229, 59, 143, 254, 223, 215, 5, 21, 86, 236, 16, 94, 216, 105,
+            130, 241, 34, 160, 93, 39, 40, 217, 103, 120, 228, 235, 150,
+        ];
 
-        let hash = ModuleHash::xxhash(wasm);
+        let hash = ModuleHash::new(wasm);
 
         assert_eq!(hash.as_bytes(), raw);
     }
diff --git a/lib/wasix/src/runtime/package_loader/builtin_loader.rs b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
index be4ed7de8e..71b786b3bc 100644
--- a/lib/wasix/src/runtime/package_loader/builtin_loader.rs
+++ b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
@@ -1,20 +1,21 @@
 use std::{
     collections::HashMap,
-    fmt::Write as _,
-    io::{ErrorKind, Write as _},
+    io::{ErrorKind, Read, Write as _},
     path::PathBuf,
     sync::{Arc, RwLock},
 };
 
-use anyhow::{Context, Error};
+use anyhow::{Context, Error, bail};
 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 +79,10 @@ impl BuiltinPackageLoader {
         }
     }
 
+    pub fn cache(&self) -> Option<&FileSystemCache> {
+        self.cache.as_ref()
+    }
+
     pub fn validate_cache(
         &self,
         mode: CacheValidationMode,
@@ -159,13 +164,13 @@ impl BuiltinPackageLoader {
             return Ok(Some(cached));
         }
 
-        if let Some(cache) = self.cache.as_ref() {
-            if let Some(cached) = cache.lookup(hash).await? {
-                // Note: We want to propagate it to the in-memory cache, too
-                tracing::debug!("Copying from the filesystem cache to the in-memory cache");
-                self.in_memory.save(&cached, *hash);
-                return Ok(Some(cached));
-            }
+        if let Some(cache) = self.cache.as_ref()
+            && let Some(cached) = cache.lookup(hash).await?
+        {
+            // Note: We want to propagate it to the in-memory cache, too
+            tracing::debug!("Copying from the filesystem cache to the in-memory cache");
+            self.in_memory.save(&cached, *hash);
+            return Ok(Some(cached));
         }
 
         Ok(None)
@@ -278,6 +283,8 @@ impl BuiltinPackageLoader {
         }
 
         let body = response.body.context("package download failed")?;
+        let body = Self::decode_response_body(&response.headers, body)
+            .context("package download failed: could not decode response body")?;
         tracing::debug!(%url, "package_download_succeeded");
 
         let body = bytes::Bytes::from(body);
@@ -292,24 +299,89 @@ impl BuiltinPackageLoader {
         headers.insert("Accept", "application/webc".parse().unwrap());
         headers.insert("User-Agent", USER_AGENT.parse().unwrap());
 
-        if url.has_authority() {
-            if let Some(token) = self.tokens.get(url.authority()) {
-                let header = format!("Bearer {token}");
-                match header.parse() {
-                    Ok(header) => {
-                        headers.insert(http::header::AUTHORIZATION, header);
-                    }
-                    Err(e) => {
-                        tracing::warn!(
-                            error = &e as &dyn std::error::Error,
-                            "An error occurred while parsing the authorization header",
+        // Accept compressed responses.
+        // NOTE: gzip and zstd decoding is available on native platforms.
+        // In browser platforms, the fetch implementation should automatically
+        // handle decoding of gzip/zstd responses transparently.
+        headers.insert(
+            http::header::ACCEPT_ENCODING,
+            "zstd;q=1.0, gzip;q=0.8".parse().unwrap(),
+        );
+
+        if url.has_authority()
+            && let Some(token) = self.tokens.get(url.authority())
+        {
+            let header = format!("Bearer {token}");
+            match header.parse() {
+                Ok(header) => {
+                    headers.insert(http::header::AUTHORIZATION, header);
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        error = &e as &dyn std::error::Error,
+                        "An error occurred while parsing the authorization header",
+                    );
+                }
+            }
+        }
+
+        headers
+    }
+
+    /// Decode the response body according to the `Content-Encoding` header.
+    ///
+    /// * Supports `gzip` and `zstd` encodings
+    /// * Supports nested encodings (e.g. `gzip, zstd`)
+    /// * Passes through unencoded bodies or "identity" encoding unchanged
+    fn decode_response_body(headers: &HeaderMap, body: Vec<u8>) -> Result<Vec<u8>, anyhow::Error> {
+        let encodings = match headers.get(http::header::CONTENT_ENCODING) {
+            Some(header) => header
+                .to_str()
+                .context("non-utf8 content-encoding header")?
+                .split(',')
+                .map(|encoding| encoding.trim().to_ascii_lowercase())
+                .filter(|encoding| !encoding.is_empty())
+                .collect::<Vec<_>>(),
+            None => Vec::new(),
+        };
+
+        // Check if there is nothing to decode, return early.
+        // "identity" is the default encoding meaning "no encoding" (See RFC 2616 / RFC 7231)
+        if encodings.is_empty() || (encodings.len() == 1 && encodings[0] == "identity") {
+            return Ok(body);
+        }
+
+        let mut reader: Box<dyn Read> = Box::new(std::io::Cursor::new(body));
+        for encoding in encodings.iter().rev() {
+            match encoding.as_str() {
+                "gzip" => {
+                    reader = Box::new(flate2::read::GzDecoder::new(reader));
+                }
+                "zstd" => {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    {
+                        reader = Box::new(
+                            zstd::stream::read::Decoder::new(reader)
+                                .context("failed to initialize zstd decoder")?,
                         );
                     }
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                        // NOTE: in browsers this code will not be hit because
+                        // the fetch API automatically handles content decoding.
+                        bail!("zstd content-encoding is not supported on wasm32");
+                    }
                 }
+                "identity" => {}
+                other => bail!("unsupported content-encoding: {other}"),
             }
         }
 
-        headers
+        let mut decoded = Vec::new();
+        reader
+            .read_to_end(&mut decoded)
+            .context("failed to decode response body")?;
+        Ok(decoded)
     }
 }
 
@@ -369,7 +441,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 +489,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 +563,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 +580,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 +612,7 @@ impl FileSystemCache {
         })
         .await??;
 
-        Ok(())
+        Ok(path2)
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
@@ -559,14 +638,102 @@ impl FileSystemCache {
     }
 
     fn path(&self, hash: &WebcHash) -> PathBuf {
-        let hash = hash.as_bytes();
-        let mut filename = String::with_capacity(hash.len() * 2);
-        for b in hash {
-            write!(filename, "{b:02x}").unwrap();
-        }
-        filename.push_str(Self::FILE_SUFFIX);
+        self.cache_dir.join(format!(
+            "{}{}",
+            hex::encode(hash.as_bytes()),
+            Self::FILE_SUFFIX
+        ))
+    }
+
+    /// 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",
+                            );
+                        }
+                    }
+                }
+            }
 
-        self.cache_dir.join(filename)
+            Ok(state)
+        })
+        .await?
+        .context("tokio runtime failed")
     }
 }
 
@@ -586,10 +753,10 @@ impl InMemoryCache {
 
 #[cfg(test)]
 mod tests {
-    use std::{collections::VecDeque, sync::Mutex};
+    use std::{collections::VecDeque, io::Write, sync::Mutex};
 
     use futures::future::BoxFuture;
-    use http::{HeaderMap, StatusCode};
+    use http::{HeaderMap, HeaderValue, StatusCode};
     use tempfile::TempDir;
     use wasmer_config::package::PackageId;
 
@@ -660,7 +827,16 @@ mod tests {
         let request = &requests[0];
         assert_eq!(request.url, summary.dist.webc);
         assert_eq!(request.method, "GET");
-        assert_eq!(request.headers.len(), 2);
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            assert_eq!(request.headers.len(), 3);
+            assert_eq!(request.headers["Accept-Encoding"], "zstd;q=1.0, gzip;q=0.8");
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            assert_eq!(request.headers.len(), 2);
+            assert!(!request.headers.contains_key(http::header::ACCEPT_ENCODING));
+        }
         assert_eq!(request.headers["Accept"], "application/webc");
         assert_eq!(request.headers["User-Agent"], USER_AGENT);
         // Make sure we got the right package
@@ -690,11 +866,165 @@ mod tests {
     async fn cache_misses_will_trigger_a_download() {
         cache_misses_will_trigger_a_download_internal().await
     }
-}
 
-#[cfg(test)]
-mod test {
-    use super::*;
+    /// Small helper to construct headers with a given content-encoding.
+    fn headers_with_encoding(content_encoding: Option<&str>) -> HeaderMap {
+        let mut headers = HeaderMap::new();
+        if let Some(value) = content_encoding {
+            headers.insert(http::header::CONTENT_ENCODING, value.parse().unwrap());
+        }
+        headers
+    }
+
+    /// Small helper to construct headers with a raw content-encoding value.
+    fn headers_with_raw_encoding(value: &[u8]) -> HeaderMap {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            http::header::CONTENT_ENCODING,
+            HeaderValue::from_bytes(value).unwrap(),
+        );
+        headers
+    }
+
+    /// Confirm decode_response_body passes through unencoded bodies unchanged.
+    #[test]
+    fn decode_response_body_passthrough() {
+        let body = b"plain-bytes".to_vec();
+
+        let decoded =
+            BuiltinPackageLoader::decode_response_body(&headers_with_encoding(None), body.clone())
+                .unwrap();
+        assert_eq!(decoded, body);
+
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some("identity")),
+            body.clone(),
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body treats empty/whitespace encoding lists as no encoding.
+    #[test]
+    fn decode_response_body_empty_encoding_list() {
+        let body = b"plain-bytes".to_vec();
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some(" , , ")),
+            body.clone(),
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body errors on non-utf8 content-encoding headers.
+    #[test]
+    fn decode_response_body_non_utf8_encoding_header() {
+        let body = b"bytes".to_vec();
+        let err =
+            BuiltinPackageLoader::decode_response_body(&headers_with_raw_encoding(&[0xff]), body)
+                .unwrap_err();
+        let msg = err.to_string();
+        assert!(msg.contains("non-utf8 content-encoding"));
+    }
+
+    /// Confirm decode_response_body decodes gzip-encoded bodies.
+    #[test]
+    fn decode_response_body_gzip() {
+        let body = b"gzip-bytes".to_vec();
+        let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder.write_all(&body).unwrap();
+        let encoded = encoder.finish().unwrap();
+
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some("gzip")),
+            encoded,
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body ignores identity when combined with other encodings.
+    #[test]
+    fn decode_response_body_identity_and_gzip() {
+        let body = b"gzip-bytes".to_vec();
+        let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder.write_all(&body).unwrap();
+        let encoded = encoder.finish().unwrap();
+
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some("identity, gzip")),
+            encoded,
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body errors on invalid gzip payloads.
+    #[test]
+    fn decode_response_body_gzip_invalid_payload() {
+        let body = b"not-gzip".to_vec();
+        let err =
+            BuiltinPackageLoader::decode_response_body(&headers_with_encoding(Some("gzip")), body)
+                .unwrap_err();
+        let msg = err.to_string();
+        assert!(msg.contains("failed to decode response body"));
+    }
+
+    /// Confirm decode_response_body decodes zstd-encoded bodies.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn decode_response_body_zstd() {
+        let body = b"zstd-bytes".to_vec();
+        let encoded = zstd::stream::encode_all(std::io::Cursor::new(&body), 0).unwrap();
+
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some("zstd")),
+            encoded,
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body errors on invalid zstd payloads.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn decode_response_body_zstd_invalid_payload() {
+        let body = b"not-zstd".to_vec();
+        let err =
+            BuiltinPackageLoader::decode_response_body(&headers_with_encoding(Some("zstd")), body)
+                .unwrap_err();
+        let msg = err.to_string();
+        assert!(msg.contains("failed to decode response body"));
+    }
+
+    /// Confirm decode_response_body decodes layered gzip+zstd-encoded bodies.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn decode_response_body_zstd_and_gzip() {
+        let body = b"layered-bytes".to_vec();
+        let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder.write_all(&body).unwrap();
+        let gzipped = encoder.finish().unwrap();
+        let encoded = zstd::stream::encode_all(std::io::Cursor::new(gzipped), 0).unwrap();
+
+        let decoded = BuiltinPackageLoader::decode_response_body(
+            &headers_with_encoding(Some("gzip, zstd")),
+            encoded,
+        )
+        .unwrap();
+        assert_eq!(decoded, body);
+    }
+
+    /// Confirm decode_response_body errors on unknown encodings.
+    #[test]
+    fn decode_response_body_unknown_encoding() {
+        let body = b"weird".to_vec();
+        let err =
+            BuiltinPackageLoader::decode_response_body(&headers_with_encoding(Some("br")), body)
+                .unwrap_err();
+        let msg = err.to_string();
+        assert!(msg.contains("unsupported content-encoding"));
+    }
 
     // NOTE: must be a tokio test because the BuiltinPackageLoader::new()
     // constructor requires a runtime...
@@ -704,7 +1034,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 +1053,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..faf2cca2c9 100644
--- a/lib/wasix/src/runtime/package_loader/load_package_tree.rs
+++ b/lib/wasix/src/runtime/package_loader/load_package_tree.rs
@@ -6,15 +6,14 @@ use std::{
 };
 
 use anyhow::{Context, Error};
-use futures::{future::BoxFuture, StreamExt, TryStreamExt};
+use futures::{StreamExt, TryStreamExt, future::BoxFuture};
 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 virtual_fs::{FileSystem, UnionFileSystem, WebcVolumeFileSystem};
+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;
 
@@ -43,13 +62,17 @@ pub async fn load_package_tree(
     let mut containers = fetch_dependencies(loader, &resolution.package, &resolution.graph).await?;
     containers.insert(resolution.package.root_package.clone(), root.clone());
     let package_ids = containers.keys().cloned().collect();
-    let fs = filesystem(&containers, &resolution.package, root_is_local_dir)?;
+    let fs_opt = filesystem(&containers, &resolution.package, root_is_local_dir)?;
 
     let root = &resolution.package.root_package;
     let commands: Vec<BinaryPackageCommand> =
         commands(&resolution.package.commands, &containers, resolution)?;
 
-    let file_system_memory_footprint = count_file_system(&fs, Path::new("/"));
+    let file_system_memory_footprint = if let Some(fs) = &fs_opt {
+        count_file_system(fs, Path::new("/"))
+    } else {
+        0
+    };
 
     let loaded = BinaryPackage {
         id: root.clone(),
@@ -62,7 +85,7 @@ pub async fn load_package_tree(
         .map(|ts| ts as u128),
         hash: OnceCell::new(),
         entrypoint_cmd: resolution.package.entrypoint.clone(),
-        webc_fs: Arc::new(fs),
+        webc_fs: fs_opt.map(Arc::new),
         commands,
         uses: Vec::new(),
         file_system_memory_footprint,
@@ -182,16 +205,58 @@ 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)
+        && 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 +265,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 +312,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,
     )))
 }
 
@@ -320,22 +402,19 @@ fn count_file_system(fs: &dyn FileSystem, path: &Path) -> u64 {
 
 /// Given a set of [`ResolvedFileSystemMapping`]s and the [`Container`] for each
 /// package in a dependency tree, construct the resulting filesystem.
+///
+/// Returns `Ok(None)` if no filesystem mappings were specified.
 fn filesystem(
     packages: &HashMap<PackageId, Container>,
     pkg: &ResolvedPackage,
     root_is_local_dir: bool,
-) -> Result<Box<dyn FileSystem + Send + Sync>, Error> {
+) -> Result<Option<UnionFileSystem>, Error> {
     if pkg.filesystem.is_empty() {
-        return Ok(Box::new(OverlayFileSystem::<
-            virtual_fs::EmptyFileSystem,
-            Vec<WebcVolumeFileSystem>,
-        >::new(
-            virtual_fs::EmptyFileSystem::default(), vec![]
-        )));
+        return Ok(None);
     }
 
-    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,37 @@ fn filesystem(
             )
         })?;
 
-        found_v2 |= container.version() == webc::Version::V2;
-        found_v3 |= container.version() == webc::Version::V3;
+        match container.version() {
+            webc::Version::V1 => {
+                anyhow::bail!(
+                    "the package '{package}' is a webc v1 package, but webc v1 support was removed"
+                );
+            }
+            webc::Version::V2 => {
+                if found_v2.is_none() {
+                    found_v2 = Some(package.clone());
+                }
+            }
+            webc::Version::V3 => {
+                if found_v3.is_none() {
+                    found_v3 = Some(package.clone());
+                }
+            }
+            other => {
+                anyhow::bail!("the package '{package}' has an unknown webc version: {other}");
+            }
+        }
     }
 
-    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).map(Some),
+        (Some(_), None) => filesystem_v2(packages, pkg, root_is_local_dir).map(Some),
+        (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"),
     }
 }
 
@@ -361,12 +463,9 @@ fn filesystem_v3(
     packages: &HashMap<PackageId, Container>,
     pkg: &ResolvedPackage,
     root_is_local_dir: bool,
-) -> Result<Box<dyn FileSystem + Send + Sync>, Error> {
+) -> Result<UnionFileSystem, Error> {
     let mut volumes: HashMap<&PackageId, BTreeMap<String, Volume>> = HashMap::new();
 
-    let mut mountings: Vec<_> = pkg.filesystem.iter().collect();
-    mountings.sort_by_key(|m| std::cmp::Reverse(m.mount_path.as_path()));
-
     let union_fs = UnionFileSystem::new();
 
     for ResolvedFileSystemMapping {
@@ -380,6 +479,12 @@ fn filesystem_v3(
             continue;
         }
 
+        if mount_path.as_path() == Path::new("/") {
+            tracing::warn!(
+                "The \"{package}\" package wants to mount a volume at \"/\", which breaks WASIX modules' filesystems",
+            );
+        }
+
         // Note: We want to reuse existing Volume instances if we can. That way
         // we can keep the memory usage down. A webc::compat::Volume is
         // reference-counted, anyway.
@@ -403,9 +508,7 @@ fn filesystem_v3(
         union_fs.mount(volume_name.clone(), mount_path, Box::new(webc_vol))?;
     }
 
-    let fs = OverlayFileSystem::new(virtual_fs::EmptyFileSystem::default(), [union_fs]);
-
-    Ok(Box::new(fs))
+    Ok(union_fs)
 }
 
 /// Build the filesystem for webc v2 packages.
@@ -435,12 +538,10 @@ fn filesystem_v2(
     packages: &HashMap<PackageId, Container>,
     pkg: &ResolvedPackage,
     root_is_local_dir: bool,
-) -> Result<Box<dyn FileSystem + Send + Sync>, Error> {
-    let mut filesystems = Vec::new();
+) -> Result<UnionFileSystem, Error> {
     let mut volumes: HashMap<&PackageId, BTreeMap<String, Volume>> = HashMap::new();
 
-    let mut mountings: Vec<_> = pkg.filesystem.iter().collect();
-    mountings.sort_by_key(|m| std::cmp::Reverse(m.mount_path.as_path()));
+    let union_fs = UnionFileSystem::new();
 
     for ResolvedFileSystemMapping {
         mount_path,
@@ -453,6 +554,12 @@ fn filesystem_v2(
             continue;
         }
 
+        if mount_path.as_path() == Path::new("/") {
+            tracing::warn!(
+                "The \"{package}\" package wants to mount a volume at \"/\", which breaks WASIX modules' filesystems",
+            );
+        }
+
         // Note: We want to reuse existing Volume instances if we can. That way
         // we can keep the memory usage down. A webc::compat::Volume is
         // reference-counted, anyway.
@@ -474,46 +581,36 @@ fn filesystem_v2(
             format!("The \"{package}\" package doesn't have a \"{volume_name}\" volume")
         })?;
 
-        let mount_path = mount_path.clone();
-        // Get a filesystem which will map "$mount_dir/some-path" to
-        // "$original_path/some-path" on the original volume
+        // UnionFileSystem strips the mount point before forwarding paths to the
+        // mounted filesystem. That means paths are already relative to the
+        // mount root and shouldn't be stripped by mount_path.
         let fs = if let Some(original) = original_path {
             let original = PathBuf::from(original);
 
             MappedPathFileSystem::new(
                 WebcVolumeFileSystem::new(volume.clone()),
-                Box::new(move |path: &Path| {
-                    let without_mount_dir = path
-                        .strip_prefix(&mount_path)
-                        .map_err(|_| virtual_fs::FsError::BaseNotDirectory)?;
-                    Ok(original.join(without_mount_dir))
-                }) as DynPathMapper,
+                Box::new(move |path: &Path| Ok(original.join(strip_root_prefix(path))))
+                    as DynPathMapper,
             )
         } else {
             MappedPathFileSystem::new(
                 WebcVolumeFileSystem::new(volume.clone()),
-                Box::new(move |path: &Path| {
-                    let without_mount_dir = path
-                        .strip_prefix(&mount_path)
-                        .map_err(|_| virtual_fs::FsError::BaseNotDirectory)?;
-                    Ok(without_mount_dir.to_owned())
-                }) as DynPathMapper,
+                Box::new(move |path: &Path| Ok(strip_root_prefix(path))) as DynPathMapper,
             )
         };
 
-        filesystems.push(fs);
+        union_fs.mount(volume_name.clone(), mount_path, Box::new(fs))?;
     }
 
-    let fs = OverlayFileSystem::new(virtual_fs::EmptyFileSystem::default(), filesystems);
+    Ok(union_fs)
+}
 
-    Ok(Box::new(fs))
+fn strip_root_prefix(path: &Path) -> PathBuf {
+    path.strip_prefix("/").unwrap_or(path).to_owned()
 }
 
 type DynPathMapper = Box<dyn Fn(&Path) -> Result<PathBuf, virtual_fs::FsError> + Send + Sync>;
 
-/// A [`FileSystem`] implementation that lets you map the [`Path`] to something
-/// else.
-#[derive(Clone, PartialEq)]
 struct MappedPathFileSystem<F, M> {
     inner: F,
     map: M,
@@ -585,7 +682,7 @@ where
         self.inner.remove_file(&path)
     }
 
-    fn new_open_options(&self) -> virtual_fs::OpenOptions {
+    fn new_open_options(&self) -> virtual_fs::OpenOptions<'_> {
         virtual_fs::OpenOptions::new(self)
     }
 
@@ -600,6 +697,98 @@ where
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use std::{
+        collections::{BTreeMap, HashMap},
+        path::{Path, PathBuf},
+    };
+
+    use ciborium::value::Value;
+    use virtual_fs::FileSystem;
+    use wasmer_config::package::PackageId;
+    use webc::{
+        Container,
+        indexmap::IndexMap,
+        metadata::{
+            Manifest,
+            annotations::{FileSystemMapping, FileSystemMappings},
+        },
+        v2::{
+            SignatureAlgorithm,
+            read::OwnedReader,
+            write::{DirEntry, Directory, FileEntry, Writer},
+        },
+    };
+
+    use super::{ResolvedFileSystemMapping, ResolvedPackage, filesystem_v2};
+
+    #[test]
+    fn v2_filesystem_mapping_resolves_mount_paths() {
+        // Regression test: v2 fs mounts are already relative to the mount root,
+        // so stripping the mount path again breaks lookups like /public.
+        let mut manifest = Manifest::default();
+        let fs = FileSystemMappings(vec![FileSystemMapping {
+            from: None,
+            volume_name: "atom".to_string(),
+            host_path: Some("/public".to_string()),
+            mount_path: "/public".to_string(),
+        }]);
+        let mut package = IndexMap::new();
+        package.insert(
+            FileSystemMappings::KEY.to_string(),
+            Value::serialized(&fs).unwrap(),
+        );
+        manifest.package = package;
+
+        let mut public_children = BTreeMap::new();
+        public_children.insert(
+            "index.html".parse().unwrap(),
+            DirEntry::File(FileEntry::from(b"ok".as_slice())),
+        );
+        let public_dir = Directory {
+            children: public_children,
+        };
+        let mut root_children = BTreeMap::new();
+        root_children.insert("public".parse().unwrap(), DirEntry::Dir(public_dir));
+        let atom_dir = Directory {
+            children: root_children,
+        };
+
+        let writer = Writer::default().write_manifest(&manifest).unwrap();
+        let writer = writer.write_atoms(BTreeMap::new()).unwrap();
+        let writer = writer.with_volume("atom", atom_dir).unwrap();
+        let bytes = writer.finish(SignatureAlgorithm::None).unwrap();
+
+        let reader = OwnedReader::parse(bytes).unwrap();
+        let container = Container::from(reader);
+
+        let pkg_id = PackageId::new_named("ns/pkg", "0.1.0".parse().unwrap());
+        let mut packages = HashMap::new();
+        packages.insert(pkg_id.clone(), container);
+
+        let pkg = ResolvedPackage {
+            root_package: pkg_id.clone(),
+            commands: BTreeMap::new(),
+            entrypoint: None,
+            filesystem: vec![ResolvedFileSystemMapping {
+                mount_path: PathBuf::from("/public"),
+                volume_name: "atom".to_string(),
+                original_path: Some("/public".to_string()),
+                package: pkg_id,
+            }],
+        };
+
+        let union_fs = filesystem_v2(&packages, &pkg, false).unwrap();
+        assert!(union_fs.metadata(Path::new("/public")).unwrap().is_dir());
+        assert!(
+            union_fs
+                .metadata(Path::new("/public/index.html"))
+                .unwrap()
+                .is_file()
+        );
+    }
+}
 impl<F, M> virtual_fs::FileOpener for MappedPathFileSystem<F, M>
 where
     F: FileSystem,
diff --git a/lib/wasix/src/runtime/package_loader/mod.rs b/lib/wasix/src/runtime/package_loader/mod.rs
index ddbf45e470..64fdeb4d41 100644
--- a/lib/wasix/src/runtime/package_loader/mod.rs
+++ b/lib/wasix/src/runtime/package_loader/mod.rs
@@ -5,5 +5,5 @@ mod unsupported;
 
 pub use self::{
     builtin_loader::BuiltinPackageLoader, load_package_tree::load_package_tree,
-    types::to_module_hash, types::PackageLoader, unsupported::UnsupportedPackageLoader,
+    types::PackageLoader, types::to_module_hash, unsupported::UnsupportedPackageLoader,
 };
diff --git a/lib/wasix/src/runtime/package_loader/types.rs b/lib/wasix/src/runtime/package_loader/types.rs
index 3eeb1cbf70..2364fbe2fb 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,
@@ -10,7 +10,7 @@ use crate::{
 
 pub fn to_module_hash(value: webc::metadata::AtomSignature) -> wasmer_types::ModuleHash {
     match value {
-        webc::metadata::AtomSignature::Sha256(bytes) => wasmer_types::ModuleHash::Sha256(bytes),
+        webc::metadata::AtomSignature::Sha256(bytes) => wasmer_types::ModuleHash::from_bytes(bytes),
     }
 }
 
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..f0d18d6fe4 100644
--- a/lib/wasix/src/runtime/resolver/backend_source.rs
+++ b/lib/wasix/src/runtime/resolver/backend_source.rs
@@ -1,5 +1,5 @@
 use std::{
-    path::PathBuf,
+    path::{MAIN_SEPARATOR_STR, PathBuf},
     sync::Arc,
     time::{Duration, SystemTime},
 };
@@ -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,23 +285,33 @@ 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) {
-                tracing::warn!(
-                    package_name,
-                    error = &*e,
-                    "An error occurred while caching the GraphQL response",
-                );
-            }
+        if let Some(cache) = &self.cache
+            && let Err(e) = cache.update(&package_name, &response)
+        {
+            tracing::warn!(
+                package_name,
+                error = &*e,
+                "An error occurred while caching the GraphQL response",
+            );
         }
 
-        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()
@@ -433,7 +460,8 @@ impl FileSystemCache {
     }
 
     fn path(&self, package_name: &str) -> PathBuf {
-        self.cache_dir.join(package_name)
+        self.cache_dir
+            .join(package_name.replace(MAIN_SEPARATOR_STR, "#"))
     }
 
     fn lookup_cached_query(&self, package_name: &str) -> Result<Option<WebQuery>, Error> {
@@ -538,14 +566,6 @@ struct CacheEntry {
     response: WebQuery,
 }
 
-/// Cache entry for a webc lookup by hash.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-struct HashCacheEntry {
-    unix_timestamp: u64,
-    hash: String,
-    response: WebQuery,
-}
-
 impl CacheEntry {
     fn is_still_valid(&self, timeout: Duration) -> bool {
         let timestamp = SystemTime::UNIX_EPOCH + Duration::from_secs(self.unix_timestamp);
@@ -678,18 +698,13 @@ pub struct WebQueryGetPackageVersion {
     pub v3: WebQueryGetPackageVersionDistribution,
 }
 
-#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, Default)]
 pub enum WebCVersion {
+    #[default]
     V2,
     V3,
 }
 
-impl Default for WebCVersion {
-    fn default() -> Self {
-        Self::V2
-    }
-}
-
 impl From<WebCVersion> for webc::Version {
     fn from(val: WebCVersion) -> Self {
         match val {
diff --git a/lib/wasix/src/runtime/resolver/filesystem_source.rs b/lib/wasix/src/runtime/resolver/filesystem_source.rs
index 471fa18b9b..cbda4f9c7a 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..cbd97dcad5 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(),
+            }),
         }
     }
 }
@@ -161,16 +189,22 @@ mod tests {
     use tempfile::TempDir;
 
     use crate::runtime::resolver::{
-        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
         Dependency, WebcHash,
+        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
     };
 
     use super::*;
 
     const PYTHON: &[u8] = include_bytes!("../../../../c-api/examples/assets/python-0.1.0.wasmer");
-    const COREUTILS_16: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc");
-    const COREUTILS_11: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc");
-    const BASH: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc");
+    const COREUTILS_16: &[u8] = include_bytes!(
+        "../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc"
+    );
+    const COREUTILS_11: &[u8] = include_bytes!(
+        "../../../../../tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc"
+    );
+    const BASH: &[u8] = include_bytes!(
+        "../../../../../tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc"
+    );
 
     #[test]
     fn load_a_directory_tree() {
diff --git a/lib/wasix/src/runtime/resolver/inputs.rs b/lib/wasix/src/runtime/resolver/inputs.rs
index db0cea3b03..023a611991 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::{Manifest, UrlOrManifest, annotations::Wapm as WapmAnnotations};
 
 /// 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,16 +288,16 @@ 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();
-            if let Ok(amt) = file.read_to_end(&mut hash) {
-                if amt == 32 {
-                    return Ok(WebcHash::from_bytes(hash[0..32].try_into().unwrap()));
-                }
+            if let Ok(amt) = file.read_to_end(&mut hash)
+                && amt == 32
+            {
+                return Ok(WebcHash::from_bytes(hash[0..32].try_into().unwrap()));
             }
         }
 
@@ -352,11 +350,7 @@ impl From<[u8; 32]> for WebcHash {
 
 impl Display for WebcHash {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for byte in self.0 {
-            write!(f, "{byte:02X}")?;
-        }
-
-        Ok(())
+        write!(f, "{}", hex::encode_upper(self.0))
     }
 }
 
diff --git a/lib/wasix/src/runtime/resolver/mod.rs b/lib/wasix/src/runtime/resolver/mod.rs
index bc6a52daea..f417de4c28 100644
--- a/lib/wasix/src/runtime/resolver/mod.rs
+++ b/lib/wasix/src/runtime/resolver/mod.rs
@@ -22,7 +22,7 @@ pub use self::{
         DependencyGraph, Edge, ItemLocation, Node, Resolution, ResolvedFileSystemMapping,
         ResolvedPackage,
     },
-    resolve::{resolve, ResolveError},
+    resolve::{ResolveError, resolve},
     source::{QueryError, Source},
     web_source::WebSource,
 };
diff --git a/lib/wasix/src/runtime/resolver/multi_source.rs b/lib/wasix/src/runtime/resolver/multi_source.rs
index 2dc3af3c4c..981e35c51b 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 => {
-                    continue
+                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..45a03644a8 100644
--- a/lib/wasix/src/runtime/resolver/resolve.rs
+++ b/lib/wasix/src/runtime/resolver/resolve.rs
@@ -11,9 +11,9 @@ use semver::Version;
 use wasmer_config::package::{PackageId, PackageSource};
 
 use crate::runtime::resolver::{
-    outputs::{Edge, Node},
     DependencyGraph, ItemLocation, PackageInfo, PackageSummary, QueryError, Resolution,
     ResolvedPackage, Source,
+    outputs::{Edge, Node},
 };
 
 use super::ResolvedFileSystemMapping;
@@ -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")
         }
     }
 }
@@ -290,16 +290,16 @@ fn resolve_package(dependency_graph: &DependencyGraph) -> Result<ResolvedPackage
         let pkg = &node.pkg;
 
         // update the entrypoint, if necessary
-        if entrypoint.is_none() {
-            if let Some(entry) = &pkg.entrypoint {
-                tracing::trace!(
-                    entrypoint = entry.as_str(),
-                    parent=%id,
-                    "Inheriting the entrypoint",
-                );
+        if entrypoint.is_none()
+            && let Some(entry) = &pkg.entrypoint
+        {
+            tracing::trace!(
+                entrypoint = entry.as_str(),
+                parent=%id,
+                "Inheriting the entrypoint",
+            );
 
-                entrypoint = Some(entry.clone());
-            }
+            entrypoint = Some(entry.clone());
         }
 
         for cmd in &pkg.commands {
@@ -385,8 +385,8 @@ mod tests {
     use wasmer_config::package::NamedPackageIdent;
 
     use crate::runtime::resolver::{
-        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
         Dependency, InMemorySource, MultiSource,
+        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
     };
 
     use super::*;
@@ -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/utils.rs b/lib/wasix/src/runtime/resolver/utils.rs
index 11f8350597..1916b5113e 100644
--- a/lib/wasix/src/runtime/resolver/utils.rs
+++ b/lib/wasix/src/runtime/resolver/utils.rs
@@ -39,18 +39,17 @@ pub(crate) fn webc_headers() -> HeaderMap {
 pub(crate) fn http_error(response: &HttpResponse) -> Error {
     let status = response.status;
 
-    if status == StatusCode::SERVICE_UNAVAILABLE {
-        if let Some(retry_after) = response
+    if status == StatusCode::SERVICE_UNAVAILABLE
+        && let Some(retry_after) = response
             .headers
             .get("Retry-After")
             .and_then(|retry_after| retry_after.to_str().ok())
-        {
-            tracing::debug!(
-                %retry_after,
-                "Received 503 Service Unavailable while looking up a package. The backend may still be generating the *.webc file.",
-            );
-            return anyhow::anyhow!("{status} (Retry After: {retry_after})");
-        }
+    {
+        tracing::debug!(
+            %retry_after,
+            "Received 503 Service Unavailable while looking up a package. The backend may still be generating the *.webc file.",
+        );
+        return anyhow::anyhow!("{status} (Retry After: {retry_after})");
     }
 
     Error::msg(status)
diff --git a/lib/wasix/src/runtime/resolver/web_source.rs b/lib/wasix/src/runtime/resolver/web_source.rs
index 0660e752d9..3eedce845b 100644
--- a/lib/wasix/src/runtime/resolver/web_source.rs
+++ b/lib/wasix/src/runtime/resolver/web_source.rs
@@ -1,5 +1,4 @@
 use std::{
-    fmt::Write as _,
     io::Write,
     path::{Path, PathBuf},
     sync::Arc,
@@ -12,7 +11,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},
@@ -137,19 +136,18 @@ impl WebSource {
                 )
             })?;
 
-        if let Some(etag) = etag {
-            if let Err(e) = self
+        if let Some(etag) = etag
+            && let Err(e) = self
                 .atomically_save_file(path.with_extension("etag"), etag.as_bytes())
                 .await
-            {
-                tracing::warn!(
-                    error=&*e,
-                    %etag,
-                    %url,
-                    path=%path.display(),
-                    "Unable to save the etag file",
-                )
-            }
+        {
+            tracing::warn!(
+                error=&*e,
+                %etag,
+                %url,
+                path=%path.display(),
+                "Unable to save the etag file",
+            )
         }
 
         Ok(path)
@@ -224,17 +222,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 +234,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,16 +252,30 @@ 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);
     let hash = hasher.finalize();
-    let mut buffer = String::with_capacity(hash.len() * 2);
-    for byte in hash {
-        write!(buffer, "{byte:02X}").expect("Unreachable");
-    }
-
-    buffer
+    hex::encode_upper(hash)
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -331,13 +334,13 @@ fn classify_cache_using_mtime(
         } => {
             return Err(CacheState::UnableToVerify { path });
         }
-        CacheInfo::Miss { .. } => return Err(CacheState::Miss),
+        CacheInfo::Miss => return Err(CacheState::Miss),
     };
 
-    if let Ok(time_since_last_modified) = last_modified.elapsed() {
-        if time_since_last_modified <= invalidation_threshold {
-            return Ok(path);
-        }
+    if let Ok(time_since_last_modified) = last_modified.elapsed()
+        && time_since_last_modified <= invalidation_threshold
+    {
+        return Ok(path);
     }
 
     match etag {
@@ -376,7 +379,7 @@ mod tests {
     use std::{collections::VecDeque, sync::Mutex};
 
     use futures::future::BoxFuture;
-    use http::{header::IntoHeaderName, HeaderMap, StatusCode};
+    use http::{HeaderMap, StatusCode, header::IntoHeaderName};
     use tempfile::TempDir;
 
     use crate::http::HttpResponse;
@@ -384,7 +387,9 @@ mod tests {
     use super::*;
 
     const PYTHON: &[u8] = include_bytes!("../../../../c-api/examples/assets/python-0.1.0.wasmer");
-    const COREUTILS: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc");
+    const COREUTILS: &[u8] = include_bytes!(
+        "../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc"
+    );
     const DUMMY_URL: &str = "http://my-registry.io/some/package";
     const DUMMY_URL_HASH: &str = "4D7481F44E1D971A8C60D3C7BD505E2727602CF9369ED623920E029C2BA2351D";
 
diff --git a/lib/wasix/src/runtime/task_manager/mod.rs b/lib/wasix/src/runtime/task_manager/mod.rs
index cf9c071c16..2a6457ebc4 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::{StoreSnapshot, WasiEnv, WasiFunctionEnv, WasiThread, capture_store_snapshot};
+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 [`SpawnMemoryTypeOrStore`].
+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..7da09198e9 100644
--- a/lib/wasix/src/runtime/task_manager/tokio.rs
+++ b/lib/wasix/src/runtime/task_manager/tokio.rs
@@ -1,12 +1,15 @@
 use std::sync::Mutex;
 use std::{num::NonZeroUsize, pin::Pin, sync::Arc, time::Duration};
 
-use futures::{future::BoxFuture, Future};
+use futures::{Future, future::BoxFuture};
 use tokio::runtime::{Handle, Runtime};
+use virtual_mio::block_on;
+use wasmer::AsStoreMut;
 
-use crate::{os::task::thread::WasiThreadError, WasiFunctionEnv};
+use crate::runtime::SpawnType;
+use crate::{WasiFunctionEnv, os::task::thread::WasiThreadError};
 
-use super::{TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
+use super::{SpawnMemoryTypeOrStore, TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
 
 #[derive(Debug, Clone)]
 pub enum RuntimeOrHandle {
@@ -26,10 +29,10 @@ impl From<Runtime> for RuntimeOrHandle {
 
 impl Drop for RuntimeOrHandle {
     fn drop(&mut self) {
-        if let Self::Runtime(_, runtime) = self {
-            if let Some(h) = runtime.lock().unwrap().take() {
-                h.shutdown_timeout(Duration::from_secs(0))
-            }
+        if let Self::Runtime(_, runtime) = self
+            && let Some(h) = runtime.lock().unwrap().take()
+        {
+            h.shutdown_timeout(Duration::from_secs(0))
         }
     }
 }
@@ -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 {
+                    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..4f2c7745b1 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::{
+    Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiThreadError,
     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},
 };
 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>) {
@@ -614,20 +698,24 @@ impl WasiEnvBuilder {
     /// Sets the FileSystem to be used with this WASI instance.
     ///
     /// This is usually used in case a custom `virtual_fs::FileSystem` is needed.
-    pub fn fs(mut self, fs: Box<dyn virtual_fs::FileSystem + Send + Sync>) -> Self {
+    pub fn fs(mut self, fs: impl Into<Arc<dyn virtual_fs::FileSystem + Send + Sync>>) -> Self {
         self.set_fs(fs);
         self
     }
 
-    pub fn set_fs(&mut self, fs: Box<dyn virtual_fs::FileSystem + Send + Sync>) {
-        self.fs = Some(WasiFsRoot::Backing(Arc::new(fs)));
+    pub fn set_fs(&mut self, fs: impl Into<Arc<dyn virtual_fs::FileSystem + Send + Sync>>) {
+        self.fs = Some(WasiFsRoot::Backing(fs.into()));
+    }
+
+    pub(crate) fn set_fs_root(&mut self, fs: WasiFsRoot) {
+        self.fs = Some(fs);
     }
 
     /// Sets a new sandbox FileSystem to be used with this WASI instance.
     ///
     /// This is usually used in case a custom `virtual_fs::FileSystem` is needed.
     pub fn sandbox_fs(mut self, fs: TmpFileSystem) -> Self {
-        self.fs = Some(WasiFsRoot::Sandbox(Arc::new(fs)));
+        self.fs = Some(WasiFsRoot::Sandbox(fs));
         self
     }
 
@@ -639,6 +727,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 +772,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)]);
+    #[cfg(feature = "journal")]
+    pub fn with_stop_running_after_snapshot(&mut self, stop_running: bool) {
+        self.stop_running_after_snapshot = stop_running;
     }
 
-    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);
-    }
-
-    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
@@ -724,7 +787,7 @@ impl WasiEnvBuilder {
     /// Returns the error from `WasiFs::new` if there's an error
     ///
     /// NOTE: You should prefer to not work directly with [`WasiEnvInit`].
-    /// Use [`WasiEnvBuilder::run`] or [`WasiEnvBuilder::run_with_store`] instead
+    /// Use [`WasiEnvBuilder::build`] or [`WasiEnvBuilder::instantiate`] instead
     /// to ensure proper invokation of WASI modules.
     pub fn build_init(mut self) -> Result<WasiEnvInit, WasiStateCreationError> {
         for arg in self.args.iter() {
@@ -752,23 +815,20 @@ 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)"),
+                    ));
                 }
 
                 None => (),
             }
 
-            if env_value.iter().any(|&ch| ch == 0) {
+            if env_value.contains(&0) {
                 return Err(WasiStateCreationError::EnvironmentVariableFormatError(
                     format!(
                         "found nul byte in env var value \"{}\" (key=value)",
@@ -778,13 +838,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
@@ -794,7 +847,7 @@ impl WasiEnvBuilder {
         let fs_backing = self
             .fs
             .take()
-            .unwrap_or_else(|| WasiFsRoot::Sandbox(Arc::new(TmpFileSystem::new())));
+            .unwrap_or_else(|| WasiFsRoot::Sandbox(TmpFileSystem::new()));
 
         if let Some(dir) = &self.current_dir {
             match fs_backing.read_dir(dir) {
@@ -865,13 +918,14 @@ impl WasiEnvBuilder {
 
         let state = WasiState {
             fs: wasi_fs,
-            secret: rand::thread_rng().gen::<[u8; 32]>(),
+            secret: rand::thread_rng().r#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 +933,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 +989,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 +1007,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 +1022,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 +1040,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 +1051,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 +1219,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/context_switching.rs b/lib/wasix/src/state/context_switching.rs
new file mode 100644
index 0000000000..c65825f371
--- /dev/null
+++ b/lib/wasix/src/state/context_switching.rs
@@ -0,0 +1,486 @@
+use crate::{
+    WasiError, WasiFunctionEnv,
+    utils::thread_local_executor::{
+        ThreadLocalExecutor, ThreadLocalSpawner, ThreadLocalSpawnerError,
+    },
+};
+use futures::{
+    TryFutureExt,
+    channel::oneshot::{self, Sender},
+};
+use std::{
+    collections::BTreeMap,
+    mem::forget,
+    sync::{
+        Arc, RwLock, Weak,
+        atomic::{AtomicU64, Ordering},
+    },
+};
+use thiserror::Error;
+use tracing::trace;
+use wasmer::{RuntimeError, Store};
+use wasmer_wasix_types::wasi::ExitCode;
+
+/// The context-switching environment represents all state for WASIX context-switching
+/// on a single host thread.
+#[derive(Debug)]
+pub(crate) struct ContextSwitchingEnvironment {
+    // TODO: We might be able to get rid of this Arc by passing an AsyncFunctionEnvMut to the functions instead
+    //       We need to be super-careful about memory leaks by cyclical references if we do that change.
+    //       The Arc allows us to have weak references to the ContextSwitchingEnvironment indepenend of the WasiEnv.
+    inner: Arc<ContextSwitchingEnvironmentInner>,
+}
+
+#[derive(Debug)]
+struct ContextSwitchingEnvironmentInner {
+    /// List of the unblockers for all suspended contexts
+    unblockers: RwLock<BTreeMap<u64, Sender<Result<(), RuntimeError>>>>,
+    /// The ID of the currently active context
+    current_context_id: AtomicU64,
+    /// The next available context ID
+    next_available_context_id: AtomicU64,
+    /// This spawner can be used to spawn tasks onto the thread-local executor
+    /// associated with this context-switching environment
+    spawner: ThreadLocalSpawner,
+}
+
+/// Errors that can occur during a context switch
+#[derive(Debug, Error)]
+pub enum ContextSwitchError {
+    #[error("Target context to switch to is missing")]
+    SwitchTargetMissing,
+}
+
+const MAIN_CONTEXT_ID: u64 = 0;
+
+/// Contexts will trap with this error as a RuntimeError::user when they are canceled
+///
+/// If encountered in a host function it MUST be propagated to the context's entrypoint.
+/// To make it harder to run into that behaviour by ignoring this error, dropping it
+/// will cause a panic with a message that it was not propagated properly. If you think
+/// you know what you are doing, you can call `defuse` (or just forget it) to avoid
+/// the panic.
+///
+/// When it bubbles up to the start of the entrypoint function of a context, it will be
+/// handled by just letting the context exit silently.
+#[derive(Error, Debug)]
+#[error("Context was canceled")]
+pub struct ContextCanceled(());
+impl ContextCanceled {
+    /// Defuse the ContextCanceled so it does not panic when dropped
+    pub fn defuse(self) {
+        // Consume self without panicking
+        forget(self);
+    }
+}
+impl Drop for ContextCanceled {
+    fn drop(&mut self) {
+        panic!(
+            "A ContextCanceled error was dropped without being propagated to the context's entrypoint. This is likely a bug in a host function, please make sure to propagate ContextCanceled errors properly."
+        );
+    }
+}
+
+/// Contexts will trap with this error as a RuntimeError::user when they entrypoint returns
+///
+/// It is not allowed for context entrypoints to return normally, they must always
+/// either get destroyed while suspended or trap with an error (like ContextCanceled)
+///
+/// This error will be picked up by the main context and cause it to trap as well.
+#[derive(Error, Debug)]
+#[error("The entrypoint of context {0} returned which is not allowed")]
+pub struct ContextEntrypointReturned(u64);
+
+impl ContextSwitchingEnvironment {
+    fn new(spawner: ThreadLocalSpawner) -> Self {
+        Self {
+            inner: Arc::new(ContextSwitchingEnvironmentInner {
+                unblockers: RwLock::new(BTreeMap::new()),
+                current_context_id: AtomicU64::new(MAIN_CONTEXT_ID),
+                next_available_context_id: AtomicU64::new(MAIN_CONTEXT_ID + 1),
+                spawner,
+            }),
+        }
+    }
+
+    /// Run the main context function in a context-switching environment
+    ///
+    /// This call blocks until the entrypoint returns or traps
+    pub(crate) fn run_main_context(
+        ctx: &WasiFunctionEnv,
+        mut store: Store,
+        entrypoint: wasmer::Function,
+        params: Vec<wasmer::Value>,
+    ) -> (Store, Result<Box<[wasmer::Value]>, RuntimeError>) {
+        // If we are already in a context-switching environment, something went wrong
+        if ctx
+            .data_mut(&mut store)
+            .context_switching_environment
+            .is_some()
+        {
+            panic!(
+                "Failed to start a WASIX main context as there was already a context-switching environment present."
+            );
+        }
+
+        // Do a normal call and dont install the context switching env, if the engine does not support async
+        let engine_supports_async = store.engine().supports_async();
+        if !engine_supports_async {
+            let result = entrypoint.call(&mut store, &params);
+            return (store, result);
+        }
+
+        // Create a new executor
+        let mut local_executor = ThreadLocalExecutor::new();
+
+        let this = Self::new(local_executor.spawner());
+
+        // Add the context-switching environment to the WasiEnv
+        let previous = ctx
+            .data_mut(&mut store)
+            .context_switching_environment
+            .replace(this);
+        assert!(previous.is_none()); // Should never be hit because of the check at the top
+
+        // Turn the store into an async store and run the entrypoint
+        let store_async = store.into_async();
+        let result = local_executor.run_until(entrypoint.call_async(&store_async, params));
+
+        // Process if this was terminated by a context entrypoint returning
+        let result = match &result {
+            Err(e) => match e.downcast_ref::<ContextEntrypointReturned>() {
+                Some(ContextEntrypointReturned(id)) => {
+                    // Context entrypoint returned, which is not allowed
+                    // Exit with code 129
+                    tracing::error!("The entrypoint of context {id} returned which is not allowed");
+                    Err(RuntimeError::user(
+                        WasiError::Exit(ExitCode::from(129)).into(),
+                    ))
+                }
+                _ => result,
+            },
+            _ => result,
+        };
+        tracing::trace!("Main context finished execution and returned {result:?}");
+
+        // Drop the executor to ensure all references to the StoreAsync are gone and convert back to a normal store
+        drop(local_executor);
+        let mut store = store_async.into_store().ok().unwrap();
+
+        // Remove the context-switching environment from the WasiEnv
+        let env = ctx.data_mut(&mut store);
+
+        env.context_switching_environment
+            .take()
+            .or_else(|| {
+                env.vfork
+                    .as_mut()
+                    .and_then(|vfork| vfork.env.context_switching_environment.take())
+                    .inspect(|_| {
+                        // Grace for vforks, so they don't bring everything down with them.
+                        // This is still an error.
+                        // The message below is oversimplified there is more nuance to this.
+                        tracing::error!("Exiting a vforked process in any other way than calling `_exit()` is undefined behavior but the current program just did that.");
+                    })
+            })
+            .expect("Failed to remove wasix context-switching environment from WASIX env after main context finished. This means we lost it somehow which should never happen.");
+
+        (store, result)
+    }
+
+    /// Get the ID of the currently active context
+    pub(crate) fn active_context_id(&self) -> u64 {
+        self.inner.current_context_id.load(Ordering::Relaxed)
+    }
+
+    /// Get the id of the main context (0)
+    pub(crate) fn main_context_id(&self) -> u64 {
+        MAIN_CONTEXT_ID
+    }
+
+    pub(crate) fn destroy_context(&self, target_context_id: &u64) -> bool {
+        // For now this only queues the context up for destruction by removing its unblocker.
+        // This will only cause destruction when the context_switch is called.
+        // That could cause memory issues if many contexts are created and destroyed without switching
+        // which could happen in applications that use contexts during setup, but not during main execution.
+        // We don't do immediate destruction because that would make this more complex, as it is essentially
+        // identical to switching to the target context
+        // TODO: Implement immediate destruction if the above becoms an issue
+        self.inner
+            .unblockers
+            .write()
+            .unwrap()
+            .remove(target_context_id)
+            .is_some()
+    }
+
+    /// Unblock the target context and suspend own context
+    ///
+    /// If this function succeeds, you MUST await the returned future
+    pub(crate) fn switch_context(
+        &self,
+        target_context_id: u64,
+    ) -> Result<
+        impl Future<Output = Result<(), RuntimeError>> + Send + Sync + use<> + 'static,
+        ContextSwitchError,
+    > {
+        let (own_unblocker, wait_for_unblock) = oneshot::channel::<Result<(), RuntimeError>>();
+        let wait_for_unblock = wait_for_unblock.map_err(|_| ContextCanceled(()));
+
+        // Lock contexts for this block
+        let mut unblockers = self.inner.unblockers.write().unwrap();
+        let own_context_id = self.active_context_id();
+
+        // Assert that we are unblocked
+        if unblockers.get(&own_context_id).is_some() {
+            // This should never happen, because if we are blocked, we should not be running code at all
+            //
+            // This is a bug in WASIX and should never happen, so we panic here.
+            panic!("There is already a unblock present for the current context {own_context_id}");
+        }
+
+        // Assert that the target is blocked
+        let Some(unblock_target) = unblockers.remove(&target_context_id) else {
+            return Err(ContextSwitchError::SwitchTargetMissing);
+        };
+
+        // Unblock the target
+        // Dont mark ourself as blocked yet, as we first need to know that unblocking succeeded
+        let unblock_result: std::result::Result<(), std::result::Result<(), RuntimeError>> =
+            unblock_target.send(Ok(()));
+        let Ok(_) = unblock_result else {
+            // If there is a unblock function in unblockers, the target context must be awaiting the related future.
+            // One way we can get into this path is, when the target context was already resumed and we somehow managed to keep the unblocker around.
+            // This can't happen as calling the unblocker consumes it.
+            // Another way this could happen is if the future waiting for the unblocker was canceled before we called it.
+            // This should not happen. This would be a bug in WASIX.
+            // Another way this could happen is if the target context never awaited the unblocker future in the first place.
+            // This also would be a bug in WASIX.
+            //
+            // So if we reach this path it is a bug in WASIX and should never happen, so we panic here.
+            panic!(
+                "Context {own_context_id} tried to unblock context {target_context_id} but the unblock target does not seem to exist."
+            );
+        };
+
+        // After we have unblocked the target, we can insert our own unblock function
+        unblockers.insert(own_context_id, own_unblocker);
+        let weak_inner = Arc::downgrade(&self.inner);
+        Ok(async move {
+            let unblock_result = wait_for_unblock.await;
+
+            // Handle if we were canceled instead of being unblocked
+            let result = match unblock_result {
+                Ok(v) => v,
+                Err(canceled) => {
+                    tracing::trace!("Canceled context {own_context_id} while it was suspended");
+
+                    // When our context was canceled return the `ContextCanceled` error.
+                    // It will be handled by the entrypoint wrapper and the context will exit silently.
+                    //
+                    // If we reach this point, we must try to restore our context ID as it will not be read again
+                    return Err(RuntimeError::user(canceled.into()));
+                }
+            };
+
+            // Restore our own context ID
+            let Some(inner) = Weak::upgrade(&weak_inner) else {
+                // The context-switching environment has been dropped, so we can't proceed
+                //
+                // This should only happen during shutdown when the ContextSwitchingEnvironment and thus the list of unblockers
+                // is dropped and the futures continue being polled (because dropping that list would cause all wait_for_unblock
+                // futures to resolve to canceled).
+                // However looking at the implementation in `run_main_context` this should not happen, as we drop the executor
+                // before dropping the environment,
+                //
+                // In a future implementation that allows the executor to outlive the environment, we should handle this case,
+                // most likely by returning a `ContextCanceled` error here as well.
+                // For now this should never happen, so it's a WASIX bug, so we panic here.
+                panic!(
+                    "The switch future for context {own_context_id} was polled after the context-switching environment was dropped, this should not happen"
+                );
+            };
+            inner
+                .current_context_id
+                .store(own_context_id, Ordering::Relaxed);
+            drop(inner);
+
+            result
+        })
+    }
+
+    /// Create a new context and spawn it onto the thread-local executor
+    ///
+    /// The entrypoint function is called when the context is unblocked for the first time
+    ///
+    /// If entrypoint returns, it must be a RuntimeError, as it is not allowed to return normally.
+    /// If the RuntimeError is a [`ContextCanceled`], the context will just exit silently.
+    /// Otherwise, the error will be propagated to the main context.
+    ///
+    /// If the context is cancelled before it is unblocked, the entrypoint will not be called
+    pub(crate) fn create_context<F>(&self, entrypoint: F) -> u64
+    where
+        F: Future<Output = Result<(), RuntimeError>> + 'static,
+    {
+        // Create a new context ID
+        let new_context_id = self
+            .inner
+            .next_available_context_id
+            .fetch_add(1, Ordering::Relaxed);
+
+        let (own_unblocker, wait_for_unblock) = oneshot::channel::<Result<(), RuntimeError>>();
+        let wait_for_unblock = wait_for_unblock.map_err(|_| ContextCanceled(()));
+
+        // Store the unblocker
+
+        let None = self
+            .inner
+            .unblockers
+            .write()
+            .unwrap()
+            .insert(new_context_id, own_unblocker)
+        else {
+            panic!("There already is a context suspended with ID {new_context_id}");
+        };
+
+        // Create the future for the new context
+        let weak_inner = Arc::downgrade(&self.inner);
+        let context_future = async move {
+            // First wait for the unblock signal
+            let prelaunch_result = wait_for_unblock.await;
+
+            // Handle if the context was canceled before it even started
+            match prelaunch_result {
+                Ok(_) => (),
+                Err(canceled) => {
+                    trace!("Context {new_context_id} was successfully destroyed before it started");
+                    // We know what we are doing, so we can prevent the panic on drop
+                    canceled.defuse();
+                    // Context was cancelled before it was started, so we can just let it return.
+                    // This will resolve the original future passed to `spawn_local` with
+                    // `Ok(())` which should make the executor drop it properly
+                    return;
+                }
+            };
+
+            let Some(inner) = Weak::upgrade(&weak_inner) else {
+                // The context-switching environment has been dropped, so we can't proceed.
+                // See the comments on the first Weak::upgrade call in this file for background on when this can happen.
+                //
+                // Note that in case the context was canceled properly, we accept that and allowed it to exit
+                // silently (in the match block above). That could happen if the main context canceled the
+                // this context before exiting itself and the executor outlives the environment.
+                //
+                // However it should not be possible to switch to this context after the main context has exited,
+                // as there can only be one active context at a time and that one (the main context) just exited.
+                // So there can't be another context in that context-switching environment that could switch to this one.
+                panic!(
+                    "Resumed context {new_context_id} after the context-switching environment was dropped. This indicates a bug where multiple contexts are active at the same time which should never happen"
+                );
+            };
+            // Set the current context ID
+            inner
+                .current_context_id
+                .store(new_context_id, Ordering::Relaxed);
+            // Drop inner again so we don't hold a strong ref while running the entrypoint, so it cleans itself up properly
+            drop(inner);
+
+            tracing::trace!("Resumed context {new_context_id} for the first time");
+
+            // Launch the context entrypoint
+            let entrypoint_result = entrypoint.await;
+
+            // If that function returns, we need to resume the main context with an error
+            // Take the underlying error, or create a new error if the context returned a value
+            let entrypoint_result = entrypoint_result.map_or_else(
+                |e| e,
+                |_| RuntimeError::user(ContextEntrypointReturned(new_context_id).into()),
+            );
+
+            // If that function returns something went wrong.
+            // If it's a cancellation, we can just let this context run out.
+            // If it's another error, we resume the main context with the error
+            let error = match entrypoint_result.downcast::<ContextCanceled>() {
+                Ok(canceled) => {
+                    tracing::trace!(
+                        "Destroyed context {new_context_id} successfully after it was canceled"
+                    );
+                    // We know what we are doing, so we can prevent the panic on drop
+                    canceled.defuse();
+                    // Context was cancelled, so we can just let it return.
+                    // This will resolve the original future passed to `spawn_local` with
+                    // `Ok(())` which should make the executor drop it properly
+                    return;
+                }
+                Err(error) => error, // Propagate the runtime error to main
+            };
+
+            tracing::trace!("Context {new_context_id} entrypoint returned with {error:?}");
+
+            // Retrieve the main context
+            let Some(inner) = Weak::upgrade(&weak_inner) else {
+                // The context-switching environment has been dropped, so we can't proceed.
+                // See the comments on the first Weak::upgrade call in this file for background on when this can happen.
+                //
+                // Note that in case the context was canceled properly, we accept that and allowed it to exit
+                // silently (in the match block above). That could happen if the main context canceled the
+                // this context before exiting itself and the executor outlives the environment.
+                //
+                // However it should not be possible to switch to this context after the main context has exited,
+                // as there can only be one active context at a time and that one (the main context) just exited.
+                // So there can't be another context in that context-switching environment that could switch to this one.
+                //
+                // So in conclusion if we reach this point it is a bug in WASIX and should never happen, so we panic here.
+                panic!(
+                    "Context {new_context_id} entrypoint returned after the context-switching environment was dropped. This indicates a bug where multiple contexts are active at the same time which should never happen"
+                );
+            };
+
+            tracing::trace!(
+                "Resuming main context {MAIN_CONTEXT_ID} with error from context {new_context_id}"
+            );
+            let Some(main_context) = inner.unblockers.write().unwrap().remove(&MAIN_CONTEXT_ID)
+            else {
+                // The main context should always be suspended when another context returns or traps with anything but cancellation
+                panic!(
+                    "The main context should always be suspended when another context returns or traps (with anything but a cancellation)."
+                );
+            };
+            drop(inner);
+
+            // Resume the main context with the error
+            main_context
+                .send(Err(error))
+                .expect("Failed to send error to main context, this should not happen");
+        };
+
+        // Queue the future onto the thread-local executor
+        tracing::trace!("Spawning context {new_context_id} onto the thread-local executor");
+        let spawn_result = self.inner.spawner.spawn_local(context_future);
+
+        match spawn_result {
+            Ok(()) => new_context_id,
+            Err(ThreadLocalSpawnerError::LocalPoolShutDown) => {
+                // This case could happen if the executor is being shut down while it is still polling a future (this one).
+                // Which shouldn't be able with a single-threaded executor, as the shutdown would have to
+                // be initiated from within a future running on that executor.
+                // I the current WASIX context switching implemenation should not be able to produce this case,
+                // but maybe it will be possible in future implementations. If someone manages to produce this case,
+                // they should open an issue so we can discuss how to handle this case properly.
+                // If this case is reachable we could return the same error as when no context-switching environment is present,
+                panic!(
+                    "Failed to spawn context {new_context_id} because the local executor has been shut down. Please open an issue and let me know how you produced this error.",
+                );
+            }
+            Err(ThreadLocalSpawnerError::NotOnTheCorrectThread { expected, found }) => {
+                // This should never happen and is a bug in WASIX, so we panic here
+                panic!(
+                    "Failed to create context because the thread local spawner lives on {expected:?} but you are on {found:?}"
+                )
+            }
+            Err(ThreadLocalSpawnerError::SpawnError) => {
+                panic!("Failed to spawn context {new_context_id}, this should not happen");
+            }
+        }
+    }
+}
diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs
index 452109aa71..e316a21684 100644
--- a/lib/wasix/src/state/env.rs
+++ b/lib/wasix/src/state/env.rs
@@ -1,247 +1,47 @@
+#[cfg(feature = "journal")]
+use crate::journal::{DynJournal, JournalEffector, SnapshotTrigger};
+use crate::{
+    Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
+    WasiResult, WasiRuntimeError, WasiStateCreationError, WasiThreadError, WasiVFork,
+    bin_factory::{BinFactory, BinaryPackage, BinaryPackageCommand},
+    capabilities::Capabilities,
+    fs::{WasiFsRoot, WasiInodes},
+    import_object_for_all_wasi_versions,
+    os::task::{
+        control_plane::ControlPlaneError,
+        process::{WasiProcess, WasiProcessId},
+        thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId},
+    },
+    syscalls::platform_clock_time_get,
+};
+use futures::future::BoxFuture;
+use rand::Rng;
 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_mio::block_on;
 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_types::ModuleHash;
 use wasmer_wasix_types::{
     types::Signal,
     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},
-    capabilities::Capabilities,
-    fs::{WasiFsRoot, WasiInodes},
-    import_object_for_all_wasi_versions,
-    os::task::{
-        control_plane::ControlPlaneError,
-        process::{WasiProcess, WasiProcessId},
-        thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId},
-    },
-    runtime::{task_manager::InlineWaker, SpawnMemoryType},
-    syscalls::platform_clock_time_get,
-    Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
-    WasiResult, WasiRuntimeError, WasiStateCreationError, 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::{Linker, WasiState, context_switching::ContextSwitchingEnvironment, conv_env_vars};
 
 /// Data required to construct a [`WasiEnv`].
 #[derive(Debug)]
@@ -268,13 +68,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 {
@@ -288,15 +91,16 @@ impl WasiEnvInit {
 
         Self {
             state: WasiState {
-                secret: rand::thread_rng().gen::<[u8; 32]>(),
+                secret: rand::thread_rng().r#gen::<[u8; 32]>(),
                 inodes,
                 fs,
                 futexs: Default::default(),
                 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 +117,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 +165,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,
@@ -368,6 +177,13 @@ pub struct WasiEnv {
     ///  not be cloned when `WasiEnv` is cloned)
     /// TODO: We should move this outside of `WasiEnv` with some refactoring
     inner: WasiInstanceHandlesPointer,
+
+    /// Tracks the active contexts of the WASIX context switching API
+    ///
+    /// This is `None` when the main function was not launched with context switching
+    ///
+    /// Should probably only be set by [`ContextSwitchingContext::run_main_context`]
+    pub(crate) context_switching_environment: Option<ContextSwitchingEnvironment>,
 }
 
 impl std::fmt::Debug for WasiEnv {
@@ -395,7 +211,9 @@ 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,
+            context_switching_environment: None,
         }
     }
 }
@@ -435,7 +253,9 @@ 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,
+            context_switching_environment: None,
         };
         Ok((new_env, handle))
     }
@@ -451,7 +271,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 +289,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 +325,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 +335,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 +363,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 +390,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
@@ -571,6 +400,7 @@ impl WasiEnv {
             bin_factory: init.bin_factory,
             capabilities: init.capabilities,
             disable_fs_cleanup: false,
+            context_switching_environment: None,
         };
         env.owned_handles.push(thread);
 
@@ -588,56 +418,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 +512,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,18 +563,19 @@ 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.
-        if call_initialize {
-            if let Ok(initialize) = instance.exports.get_function("_initialize") {
-                if let Err(err) = crate::run_wasi_func_start(initialize, &mut store) {
-                    func_env
-                        .data(&store)
-                        .blocking_on_exit(Some(Errno::Noexec.into()));
-                    return Err(err);
-                }
+        if call_initialize && let Ok(initialize) = instance.exports.get_function("_initialize") {
+            let initialize_result = initialize.call(&mut store, &[]);
+            if let Err(err) = initialize_result {
+                func_env
+                    .data(&store)
+                    .blocking_on_exit(Some(Errno::Noexec.into()));
+                return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from(
+                    err,
+                ))));
             }
         }
 
@@ -721,14 +609,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()
+            && 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 +647,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 +672,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 +697,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 +731,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 +808,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 +829,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 +838,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 +850,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 +889,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 +898,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 +912,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,8 +992,8 @@ impl WasiEnv {
         &'a self,
         store: &'a impl AsStoreRef,
         _mem_index: u32,
-    ) -> (MemoryView<'a>, &WasiState) {
-        let memory = self.memory_view(store);
+    ) -> (MemoryView<'a>, &'a WasiState) {
+        let memory = unsafe { self.memory_view(store) };
         let state = self.state.deref();
         (memory, state)
     }
@@ -1066,8 +1007,8 @@ impl WasiEnv {
         &'a self,
         store: &'a impl AsStoreRef,
         _mem_index: u32,
-    ) -> (MemoryView<'a>, &WasiState, &WasiInodes) {
-        let memory = self.memory_view(store);
+    ) -> (MemoryView<'a>, &'a WasiState, &'a WasiInodes) {
+        let memory = unsafe { self.memory_view(store) };
         let state = self.state.deref();
         let inodes = &state.inodes;
         (memory, state, inodes)
@@ -1079,6 +1020,10 @@ impl WasiEnv {
         (state, inodes)
     }
 
+    pub fn use_package(&self, pkg: &BinaryPackage) -> Result<(), WasiStateCreationError> {
+        block_on(self.use_package_async(pkg))
+    }
+
     /// Make all the commands in a [`BinaryPackage`] available to the WASI
     /// instance.
     ///
@@ -1090,13 +1035,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 +1055,58 @@ 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 [{}] - {}",
+                                pkg.id,
+                                command.name(),
+                                err
+                            );
+                            continue;
+                        }
+                    }
+                    WasiFsRoot::Overlay(ofs) => {
+                        let root_fs = ofs.primary();
+
+                        if let Err(err) = root_fs
+                            .new_open_options_ext()
+                            .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 +1118,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",
@@ -1159,8 +1139,11 @@ impl WasiEnv {
 
                 let mut package = pkg.clone();
                 package.entrypoint_cmd = Some(command.name().to_string());
+                let package_arc = Arc::new(package);
+                self.bin_factory
+                    .set_binary(path.to_string_lossy().as_ref(), &package_arc);
                 self.bin_factory
-                    .set_binary(path.as_os_str().to_string_lossy().as_ref(), package);
+                    .set_binary(path2.to_string_lossy().as_ref(), &package_arc);
 
                 tracing::debug!(
                     package=%pkg.id,
@@ -1185,18 +1168,14 @@ 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 = block_on(BinaryPackage::from_registry(&specifier, rt)).map_err(|e| {
+                WasiStateCreationError::WasiIncludePackageError(format!(
+                    "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
-                    ))
-                },
-            )?;
             self.use_package(&pkg)?;
         }
 
@@ -1212,6 +1191,7 @@ impl WasiEnv {
         #[allow(unused_imports)]
         use std::path::Path;
 
+        use shared_buffer::OwnedBuffer;
         #[allow(unused_imports)]
         use virtual_fs::FileSystem;
 
@@ -1225,19 +1205,33 @@ 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);
                     continue;
                 }
             } else {
-                tracing::debug!("failed to add atom command [{}] to the root file system as it is not sandboxed", command);
+                tracing::debug!(
+                    "failed to add atom command [{}] to the root file system as it is not sandboxed",
+                    command
+                );
                 continue;
             }
         }
@@ -1246,32 +1240,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);
-        InlineWaker::block_on(cleanup);
+    pub fn blocking_on_exit(&self, process_exit_code: Option<ExitCode>) {
+        let cleanup = self.on_exit(process_exit_code);
+        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) {
-                    tracing::warn!("failed to save snapshot event for process exit - {}", err);
-                }
+            if self.thread.is_main()
+                && 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 +1292,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..914edc2be0 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,
+    RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiModuleInstanceHandles,
+    WasiRuntimeError, WasiThreadError,
+    runtime::task_manager::SpawnMemoryTypeOrStore,
+    state::WasiModuleTreeHandles,
     utils::{get_wasi_version, get_wasi_versions, store::restore_store_snapshot},
-    RewindStateOption, StoreSnapshot, WasiEnv, WasiError, 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,100 @@ 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 +328,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 +371,38 @@ 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 unsafe { 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 unsafe {
+                        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 +434,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 +446,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..296da797a6 100644
--- a/lib/wasix/src/state/handles/mod.rs
+++ b/lib/wasix/src/state/handles/mod.rs
@@ -1,7 +1,381 @@
 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, FunctionEnvMut, Global, Instance, Memory, MemoryView, Module,
+    Table, TypedFunction, Value,
+};
+use wasmer_wasix_types::wasi::Errno;
+
+use crate::{WasiEnv, state::LinkError};
+
+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(handles) => handles,
+            WasiModuleTreeHandles::Dynamic {
+                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(handles) => handles,
+            WasiModuleTreeHandles::Dynamic {
+                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(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(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(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        function_id: u32,
+    ) -> Result<bool, LinkError> {
+        // We need a manual deref here for the thread_local case.
+        // See: impl Deref for WasiInstanceGuard<'_> in thread_local.rs.
+        // Then, we need to allow the lint for the normal case.
+        #[allow(clippy::borrow_deref_ref)]
+        match &*ctx.data().inner() {
+            WasiModuleTreeHandles::Static(_) => Ok(false),
+            WasiModuleTreeHandles::Dynamic { linker, .. } => {
+                linker.clone().is_closure(function_id, ctx)
+            }
+        }
+    }
+}
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..0abec18766
--- /dev/null
+++ b/lib/wasix/src/state/linker.rs
@@ -0,0 +1,4351 @@
+// 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,
+    fmt::Display,
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+    sync::{
+        Arc, Barrier, Mutex, MutexGuard, RwLock, RwLockWriteGuard, TryLockError,
+        atomic::{AtomicBool, Ordering},
+    },
+};
+
+use bus::Bus;
+use derive_more::Debug;
+use shared_buffer::OwnedBuffer;
+use tracing::trace;
+use virtual_fs::{AsyncReadExt, FileSystem, FsError};
+use virtual_mio::block_on;
+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, WASM_PAGE_SIZE, WasmTypeList,
+};
+use wasmer_wasix_types::wasix::WasiMemoryLayout;
+
+use crate::{
+    Runtime, SpawnError, WasiEnv, WasiError, WasiFs, WasiFunctionEnv, WasiModuleTreeHandles,
+    WasiProcess, WasiThreadId, fs::WasiFsRoot, import_object_for_all_wasi_versions,
+    runtime::module_cache::HashedModuleData,
+};
+
+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);
+
+// 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)
+    }
+}
+
+impl Display for ModuleHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+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("Bad __tls_base export, expected a global of type I32 or I64")]
+    BadTlsBaseExport,
+
+    #[error(
+        "TLS symbol {0} cannot be resolved from module {1} because it does not export its __tls_base"
+    )]
+    MissingTlsBaseExport(String, ModuleHandle),
+}
+
+#[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("Module must export its __tls_base for exported TLS symbols to be resolved correctly")]
+    NoTlsBaseGlobalExport,
+}
+
+#[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: Option<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,
+    main_module_memory_base: u64,
+
+    // 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)?;
+
+        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"
+        );
+
+        // Give modules a non-zero memory base, since we don't want
+        // any valid pointers to point to the zero address
+        let memory_base = 2u64.pow(dylink_section.mem_info.memory_alignment);
+
+        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 = memory_base + dylink_section.mem_info.memory_size as u64;
+            if !data_end.is_multiple_of(1024) {
+                data_end + 1024 - (data_end % 1024)
+            } else {
+                data_end
+            }
+        };
+
+        if !stack_size.is_multiple_of(1024) {
+            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(),
+            memory_base,
+            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,
+            // The TLS base for the main instance is determined by reading the
+            // `__tls_base` global export from the instance after instantiation.
+            main_instance_tls_base: None,
+            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,
+            main_module_memory_base: memory_base,
+            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", 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 tls_base = get_tls_base_export(&main_instance, store)?;
+        instance_group.main_instance_tls_base = tls_base;
+
+        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 --volume .`, 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,
+        };
+        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)?;
+
+        {
+            trace!(?link_state, "Finalizing linking of main module");
+
+            let mut group_guard = linker.instance_group_state.lock().unwrap();
+            let mut linker_state = linker.linker_state.write().unwrap();
+
+            let group_state = group_guard.as_mut().unwrap();
+            group_state.finalize_pending_globals(
+                &mut linker_state,
+                store,
+                &link_state.unresolved_globals,
+            )?;
+
+            // 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")?;
+
+            linker.initialize_new_modules(group_guard, 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: Some(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", linker_state.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.
+    /// Requires a FunctionEnvMut because pending DL operations should always
+    /// be processed before acquiring any lock on the linker.
+    // TODO: we can cache this information within the group state so we don't
+    // need a write lock on the linker state here
+    pub fn is_closure(
+        &self,
+        function_id: u32,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ) -> Result<bool, LinkError> {
+        // If we can get a read lock on the linker state, do it
+        if let Ok(linker_state) = self.linker_state.try_read() {
+            return Ok(linker_state
+                .allocated_closure_functions
+                .contains_key(&function_id));
+        }
+
+        // Otherwise, fall back to the path where we apply DL ops and acquire
+        // a write lock afterwards
+        lock_instance_group_state!(
+            group_state_guard,
+            group_state,
+            self,
+            LinkError::InstanceGroupIsDead
+        );
+        write_linker_state!(linker_state, self, group_state, ctx);
+        Ok(linker_state
+            .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,
+        )?;
+
+        self.initialize_new_modules(group_state_guard, store, link_state)
+    }
+
+    fn initialize_new_modules(
+        &self,
+        // Take ownership of the guard and drop it ourselves to ensure no deadlock can happen
+        mut group_state_guard: MutexGuard<'_, Option<InstanceGroupState>>,
+        store: &mut impl AsStoreMut,
+        link_state: InProgressLinkState,
+    ) -> Result<(), LinkError> {
+        let group_state = group_state_guard.as_mut().unwrap();
+
+        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()
+            && 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::NoTlsBaseGlobalExport);
+                    };
+                    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 {
+            self.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) = 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
+            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.is_multiple_of(alignment) {
+                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 tls_base = get_tls_base_export(&instance, store)?;
+
+        let dl_instance = DlInstance {
+            instance: instance.clone(),
+            instance_handles,
+            // The TLS base of a side module's main instance is read from the module's
+            // `__tls_base` export via `get_tls_base_export`, and is not necessarily at the
+            // beginning of its memory.
+            tls_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
+                && let SymbolResolutionResult::FunctionPointer {
+                    resolved_from,
+                    function_table_index,
+                } = val
+            {
+                self.apply_resolved_function(store, name, *resolved_from, *function_table_index)?;
+            }
+        }
+        Ok(())
+    }
+
+    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 = match 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,
+                    ) {
+                        Ok(export) => export,
+                        Err(ResolveError::NoTlsBaseGlobalExport) => {
+                            return Err(LinkError::MissingTlsBaseExport(
+                                import.name().to_string(),
+                                *module_handle,
+                            ));
+                        }
+                        Err(e) => {
+                            panic!("Internal error: bad in-progress symbol resolution: {e:?}")
+                        }
+                    };
+
+                    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),
+                        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::NoTlsBaseGlobalExport);
+                    };
+                    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())
+                    .map_err(crate::flatten_runtime_error)
+            },
+        )
+    }
+
+    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.
+
+        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()
+}
+
+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, .. } => {
+                tracing::warn!("Skipping unknown dylink.0 subsection {ty}");
+            }
+            wasmparser::Dylink0Subsection::RuntimePath(path) => {
+                runtime_path.extend(path.into_iter().map(|path| path.to_string()));
+            }
+        }
+    }
+
+    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()))
+        }
+    }
+}
+
+fn get_tls_base_export(
+    instance: &Instance,
+    store: &mut impl AsStoreMut,
+) -> Result<Option<u64>, LinkError> {
+    match instance.exports.get_global("__tls_base") {
+        Ok(global) => match global.get(store) {
+            Value::I32(x) => Ok(Some(x as u64)),
+            Value::I64(x) => Ok(Some(x as u64)),
+            _ => Err(LinkError::BadTlsBaseExport),
+        },
+        Err(ExportError::Missing(_)) => Ok(None),
+        Err(ExportError::IncompatibleType) => Err(LinkError::BadTlsBaseExport),
+    }
+}
+
+#[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..fc3463c83b 100644
--- a/lib/wasix/src/state/mod.rs
+++ b/lib/wasix/src/state/mod.rs
@@ -16,10 +16,11 @@
 #![allow(clippy::cognitive_complexity, clippy::too_many_arguments)]
 
 mod builder;
+pub mod context_switching;
 mod env;
 mod func_env;
 mod handles;
-mod run;
+mod linker;
 mod types;
 
 use std::{
@@ -30,25 +31,27 @@ 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::*,
 };
 pub use crate::fs::{InodeGuard, InodeWeakGuard};
 use crate::{
-    fs::{fs_error_into_wasi_err, WasiFs, WasiFsRoot, WasiInodes, WasiStateFileGuard},
+    fs::{WasiFs, WasiFsRoot, WasiInodes, WasiStateFileGuard, fs_error_into_wasi_err},
     syscalls::types::*,
     utils::WasiParkingLot,
 };
 pub(crate) use handles::*;
+pub(crate) use linker::*;
 
 /// all the rights enabled
 pub const ALL_RIGHTS: Rights = Rights::all();
@@ -122,8 +125,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 +136,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.
@@ -202,7 +206,7 @@ impl WasiState {
             .map_err(fs_error_into_wasi_err)
     }
 
-    pub(crate) fn fs_new_open_options(&self) -> OpenOptions {
+    pub(crate) fn fs_new_open_options(&self) -> OpenOptions<'_> {
         self.fs.root_fs.new_open_options()
     }
 
@@ -255,8 +259,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..5ccb857c08 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,
@@ -16,7 +16,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 self.differ_memory.clear();
                 self.rewind = None;
             } else {
-                JournalEffector::apply_process_exit(&mut self.ctx, exit_code)
+                unsafe { JournalEffector::apply_process_exit(&mut self.ctx, exit_code) }
                     .map_err(anyhow_err_to_runtime_err)?;
             }
         } else if let Some(differ_ethereal) = differ_ethereal {
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..38dcbda799 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;
@@ -19,12 +20,12 @@ mod snapshot;
 mod tty_set;
 mod update_memory;
 
-use crate::journal::JournalEffector;
-use crate::syscalls::anyhow_err_to_runtime_err;
-use crate::syscalls::JournalSyscallPlayer;
 use crate::RewindState;
 use crate::WasiRuntimeError;
 use crate::WasiThreadId;
+use crate::journal::JournalEffector;
+use crate::syscalls::anyhow_err_to_runtime_err;
+use crate::syscalls::{JournalStdIoWrite, JournalSyscallPlayer};
 use std::borrow::Cow;
 use std::ops::Range;
 use std::time::SystemTime;
@@ -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..a6f6cf9915 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,
@@ -13,7 +13,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
             self.differ_memory.clear();
             self.rewind = None;
         } else {
-            JournalEffector::apply_process_exit(&mut self.ctx, exit_code)
+            unsafe { JournalEffector::apply_process_exit(&mut self.ctx, exit_code) }
                 .map_err(anyhow_err_to_runtime_err)?;
         }
         Ok(())
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..649960a3ef 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,
@@ -30,7 +30,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
         if let Some(ethereal_events) = differ_ethereal {
             for next in ethereal_events.drain(..) {
                 tracing::trace!("Replay(ether) snapshot event - {next:?}");
-                if let Err(err) = self.play_event(next, None) {
+                if let Err(err) = unsafe { self.play_event(next, None) } {
                     tracing::warn!("failed to replay event - {}", err);
                     return Err(err);
                 }
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..c839a8794b 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,
@@ -24,8 +24,10 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
             });
         } else {
             tracing::trace!("Replay journal - UpdateMemory");
-            JournalEffector::apply_compressed_memory(&mut self.ctx, region, &compressed_data)
-                .map_err(anyhow_err_to_runtime_err)?;
+            unsafe {
+                JournalEffector::apply_compressed_memory(&mut self.ctx, region, &compressed_data)
+            }
+            .map_err(anyhow_err_to_runtime_err)?;
         }
         Ok(())
     }
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..92a9d709f5 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,
@@ -11,13 +11,13 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
     ) -> Result<(), WasiRuntimeError> {
         match next {
             JournalEntry::InitModuleV1 { wasm_hash } => {
-                self.action_init_module(wasm_hash, differ_ethereal)?;
+                unsafe { self.action_init_module(wasm_hash, differ_ethereal) }?;
             }
             JournalEntry::ClearEtherealV1 => {
                 self.clear_ethereal(differ_ethereal);
             }
             JournalEntry::ProcessExitV1 { exit_code } => {
-                self.action_process_exit(exit_code, differ_ethereal)?;
+                unsafe { self.action_process_exit(exit_code, differ_ethereal) }?;
             }
             JournalEntry::FileDescriptorWriteV1 {
                 fd,
@@ -26,7 +26,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 is_64bit,
             } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_write(fd, offset, data, is_64bit)?;
+                    unsafe { self.action_fd_write(fd, offset, data, is_64bit) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, %offset, "Differ(ether) journal - FdWrite");
                     differ_ethereal.push(JournalEntry::FileDescriptorWriteV1 {
@@ -36,27 +36,29 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         is_64bit,
                     });
                 } else {
-                    self.action_fd_write(fd, offset, data, is_64bit)?;
+                    unsafe { self.action_fd_write(fd, offset, data, is_64bit) }?;
                 }
             }
             JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_seek(fd, offset, whence)?;
+                    unsafe { self.action_fd_seek(fd, offset, whence) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, %offset, ?whence, "Differ(ether) journal - FdSeek");
                     differ_ethereal.push(JournalEntry::FileDescriptorSeekV1 { fd, offset, whence });
                 } else {
-                    self.action_fd_seek(fd, offset, whence)?;
+                    unsafe { self.action_fd_seek(fd, offset, whence) }?;
                 }
             }
             JournalEntry::UpdateMemoryRegionV1 {
                 region,
                 compressed_data,
             } => {
-                self.action_update_compressed_memory(region, compressed_data, differ_ethereal)?;
+                unsafe {
+                    self.action_update_compressed_memory(region, compressed_data, differ_ethereal)
+                }?;
             }
             JournalEntry::CloseThreadV1 { id, exit_code } => {
-                self.action_close_thread(id, exit_code, differ_ethereal)?;
+                unsafe { self.action_close_thread(id, exit_code, differ_ethereal) }?;
             }
             JournalEntry::SetThreadV1 {
                 id,
@@ -67,25 +69,27 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 start,
                 layout,
             } => {
-                self.action_set_thread(
-                    id,
-                    call_stack,
-                    memory_stack,
-                    store_data,
-                    is_64bit,
-                    start,
-                    layout,
-                    differ_ethereal,
-                )?;
+                unsafe {
+                    self.action_set_thread(
+                        id,
+                        call_stack,
+                        memory_stack,
+                        store_data,
+                        is_64bit,
+                        start,
+                        layout,
+                        differ_ethereal,
+                    )
+                }?;
             }
             JournalEntry::CloseFileDescriptorV1 { fd } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_close(fd)?;
+                    unsafe { self.action_fd_close(fd) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, "Differ(ether) journal - FdClose");
                     differ_ethereal.push(JournalEntry::CloseFileDescriptorV1 { fd });
                 } else {
-                    self.action_fd_close(fd)?;
+                    unsafe { self.action_fd_close(fd) }?;
                 }
             }
             JournalEntry::OpenFileDescriptorV1 {
@@ -99,16 +103,45 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 fs_flags,
             } => {
                 self.real_fd.insert(fd);
-                self.action_fd_open(
-                    fd,
-                    dirfd,
-                    dirflags,
-                    path,
-                    o_flags,
-                    fs_rights_base,
-                    fs_rights_inheriting,
-                    fs_flags,
-                )?;
+                unsafe {
+                    self.action_fd_open(
+                        fd,
+                        dirfd,
+                        dirflags,
+                        path,
+                        o_flags,
+                        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);
+                unsafe {
+                    self.action_fd_open(
+                        fd,
+                        dirfd,
+                        dirflags,
+                        path,
+                        o_flags,
+                        fs_rights_base,
+                        fs_rights_inheriting,
+                        fs_flags,
+                        fd_flags,
+                    )
+                }?;
             }
             JournalEntry::RemoveDirectoryV1 { fd, path } => {
                 tracing::trace!("Replay journal - RemoveDirectory {}", path);
@@ -137,7 +170,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 .map_err(anyhow_err_to_runtime_err)?;
             }
             JournalEntry::SnapshotV1 { when, trigger } => {
-                self.action_snapshot(when, trigger, differ_ethereal)?;
+                unsafe { self.action_snapshot(when, trigger, differ_ethereal) }?;
             }
             JournalEntry::SetClockTimeV1 { clock_id, time } => {
                 tracing::trace!(?clock_id, %time, "Replay journal - ClockTimeSet");
@@ -146,12 +179,12 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
             }
             JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
                 if self.real_fd.remove(&old_fd) {
-                    self.action_fd_renumber(old_fd, new_fd)?;
+                    unsafe { self.action_fd_renumber(old_fd, new_fd) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%old_fd, %new_fd, "Differ(ether) journal - FdRenumber");
                     differ_ethereal.push(JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd });
                 } else {
-                    self.action_fd_renumber(old_fd, new_fd)?;
+                    unsafe { self.action_fd_renumber(old_fd, new_fd) }?;
                 }
             }
             JournalEntry::DuplicateFileDescriptorV1 {
@@ -159,7 +192,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 copied_fd,
             } => {
                 if self.real_fd.contains(&original_fd) {
-                    self.action_fd_dup(original_fd, copied_fd)?;
+                    unsafe { 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 +200,25 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         copied_fd,
                     });
                 } else {
-                    self.action_fd_dup(original_fd, copied_fd)?;
+                    unsafe { self.action_fd_dup(original_fd, copied_fd, false) }?;
+                }
+            }
+            JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                cloexec,
+            } => {
+                if self.real_fd.contains(&original_fd) {
+                    unsafe { 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 {
+                    unsafe { self.action_fd_dup(original_fd, copied_fd, cloexec) }?;
                 }
             }
             JournalEntry::CreateDirectoryV1 { fd, path } => {
@@ -184,7 +235,9 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 fst_flags,
             } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)?;
+                    unsafe {
+                        self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)
+                    }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, "Differ(ether) journal - PathSetTimes");
                     differ_ethereal.push(JournalEntry::PathSetTimesV1 {
@@ -196,7 +249,9 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         fst_flags,
                     });
                 } else {
-                    self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)?;
+                    unsafe {
+                        self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)
+                    }?;
                 }
             }
             JournalEntry::FileDescriptorSetTimesV1 {
@@ -206,9 +261,15 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 fst_flags,
             } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags)?
+                    unsafe { self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
-                    tracing::trace!(%fd, %st_atim, %st_mtim, ?fst_flags, "Differ(ether) journal - FdSetTimes");
+                    tracing::trace!(
+                        %fd,
+                        %st_atim,
+                        %st_mtim,
+                        ?fst_flags,
+                        "Differ(ether) journal - FdSetTimes"
+                    );
                     differ_ethereal.push(JournalEntry::FileDescriptorSetTimesV1 {
                         fd,
                         st_atim,
@@ -216,27 +277,37 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         fst_flags,
                     });
                 } else {
-                    self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags)?
+                    unsafe { self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags) }?;
                 }
             }
             JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_set_size(fd, st_size)?;
+                    unsafe { self.action_fd_set_size(fd, st_size) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, %st_size, "Differ(ether) journal - FdSetSize");
                     differ_ethereal.push(JournalEntry::FileDescriptorSetSizeV1 { fd, st_size });
                 } else {
-                    self.action_fd_set_size(fd, st_size)?;
+                    unsafe { self.action_fd_set_size(fd, st_size) }?;
+                }
+            }
+            JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags } => {
+                if self.real_fd.contains(&fd) {
+                    unsafe { 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 {
+                    unsafe { self.action_fd_set_fdflags(fd, flags) }?;
                 }
             }
             JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_set_flags(fd, flags)?;
+                    unsafe { self.action_fd_set_flags(fd, flags) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, ?flags, "Differ(ether) journal - FdSetFlags");
                     differ_ethereal.push(JournalEntry::FileDescriptorSetFlagsV1 { fd, flags });
                 } else {
-                    self.action_fd_set_flags(fd, flags)?;
+                    unsafe { self.action_fd_set_flags(fd, flags) }?;
                 }
             }
             JournalEntry::FileDescriptorSetRightsV1 {
@@ -245,7 +316,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 fs_rights_inheriting,
             } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting)?;
+                    unsafe { self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, "Differ(ether) journal - FdSetRights");
                     differ_ethereal.push(JournalEntry::FileDescriptorSetRightsV1 {
@@ -254,7 +325,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         fs_rights_inheriting,
                     });
                 } else {
-                    self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting)?;
+                    unsafe { self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting) }?;
                 }
             }
             JournalEntry::FileDescriptorAdviseV1 {
@@ -264,7 +335,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 advice,
             } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_advise(fd, offset, len, advice)?;
+                    unsafe { self.action_fd_advise(fd, offset, len, advice) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, %offset, %len, ?advice, "Differ(ether) journal - FdAdvise");
                     differ_ethereal.push(JournalEntry::FileDescriptorAdviseV1 {
@@ -274,12 +345,12 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         advice,
                     });
                 } else {
-                    self.action_fd_advise(fd, offset, len, advice)?;
+                    unsafe { self.action_fd_advise(fd, offset, len, advice) }?;
                 }
             }
             JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
                 if self.real_fd.contains(&fd) {
-                    self.action_fd_allocate(fd, offset, len)?;
+                    unsafe { self.action_fd_allocate(fd, offset, len) }?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, %offset, %len, "Differ(ether) journal - FdAllocate");
                     differ_ethereal.push(JournalEntry::FileDescriptorAllocateV1 {
@@ -288,7 +359,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         len,
                     });
                 } else {
-                    self.action_fd_allocate(fd, offset, len)?;
+                    unsafe { self.action_fd_allocate(fd, offset, len) }?;
                 }
             }
             JournalEntry::CreateHardLinkV1 {
@@ -323,13 +394,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)?;
                 }
             }
@@ -368,7 +439,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                     tracing::trace!("Differ(ether) journal - TtySet");
                     differ_ethereal.push(JournalEntry::TtySetV1 { tty, line_feeds });
                 } else {
-                    self.action_tty_set(tty, line_feeds)?;
+                    unsafe { self.action_tty_set(tty, line_feeds) }?;
                 }
             }
             JournalEntry::PortAddAddrV1 { cidr } => {
@@ -446,6 +517,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 +748,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..10368c4740 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));
+        unsafe { 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)
@@ -58,14 +75,10 @@ pub unsafe fn restore_snapshot(
             region,
             data.len()
         );
-        JournalEffector::apply_compressed_memory(&mut runner.ctx, region, &data)
+        unsafe { JournalEffector::apply_compressed_memory(&mut runner.ctx, region, &data) }
             .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..70ef4418d6 100644
--- a/lib/wasix/src/syscalls/legacy/snapshot0.rs
+++ b/lib/wasix/src/syscalls/legacy/snapshot0.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use tracing::{field, instrument, trace_span};
 use wasmer::{AsStoreMut, AsStoreRef, FunctionEnvMut, Memory, WasmPtr};
 use wasmer_wasix_types::wasi::{
@@ -7,30 +9,25 @@ use wasmer_wasix_types::wasi::{
 };
 
 use crate::{
-    mem_error_to_wasi,
+    Memory32, MemorySize, WasiEnv, WasiError, mem_error_to_wasi,
     os::task::thread::WasiThread,
     state::{PollEventBuilder, PollEventSet},
     syscalls::types,
     syscalls::{self, handle_rewind},
-    Memory32, MemorySize, WasiEnv, WasiError,
 };
 
 /// 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,
     buf: WasmPtr<Snapshot0Filestat, Memory32>,
 ) -> Errno {
-    let env = ctx.data();
-    let memory = unsafe { env.memory_view(&ctx) };
-    let result = syscalls::fd_filestat_get_old::<Memory32>(ctx.as_mut(), fd, buf);
-
-    result
+    syscalls::fd_filestat_get_old::<Memory32>(ctx.as_mut(), fd, buf)
 }
 
 /// 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,
@@ -39,18 +36,12 @@ pub fn path_filestat_get(
     path_len: u32,
     buf: WasmPtr<Snapshot0Filestat, Memory32>,
 ) -> Errno {
-    let env = ctx.data();
-    let memory = unsafe { env.memory_view(&ctx) };
-
-    let result =
-        syscalls::path_filestat_get_old::<Memory32>(ctx.as_mut(), fd, flags, path, path_len, buf);
-
-    result
+    syscalls::path_filestat_get_old::<Memory32>(ctx.as_mut(), fd, flags, path, path_len, buf)
 }
 
 /// 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,
@@ -62,7 +53,7 @@ pub fn fd_seek(
         Snapshot0Whence::Cur => Whence::Cur,
         Snapshot0Whence::End => Whence::End,
         Snapshot0Whence::Set => Whence::Set,
-        Snapshot0Whence::Unknown => return Ok(Errno::Inval),
+        _ => return Ok(Errno::Inval),
     };
     syscalls::fd_seek::<Memory32>(ctx, fd, offset, new_whence, newoffset)
 }
@@ -77,10 +68,11 @@ 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) };
+
     let mut subscriptions = Vec::new();
     let in_origs = wasi_try_mem_ok!(in_.slice(&memory, nsubscriptions));
     let in_origs = wasi_try_mem_ok!(in_origs.read_to_vec());
@@ -112,7 +104,7 @@ pub fn poll_oneoff<M: MemorySize>(
                         nbytes: 0,
                         flags: Eventrwflags::empty(),
                     },
-                    Eventtype::Unknown => return Errno::Inval,
+                    _ => return Errno::Inval,
                 },
             };
             wasi_try_mem!(event_array.index(events_seen as u64).write(event));
diff --git a/lib/wasix/src/syscalls/mod.rs b/lib/wasix/src/syscalls/mod.rs
index 26e1e81d9f..64472cc09e 100644
--- a/lib/wasix/src/syscalls/mod.rs
+++ b/lib/wasix/src/syscalls/mod.rs
@@ -1,4 +1,9 @@
-#![allow(unused, clippy::too_many_arguments, clippy::cognitive_complexity)]
+#![allow(
+    unused,
+    clippy::too_many_arguments,
+    clippy::cognitive_complexity,
+    clippy::result_large_err
+)]
 
 pub mod types {
     pub use wasmer_wasix_types::{types::*, wasi};
@@ -20,12 +25,14 @@ pub mod journal;
 pub mod wasi;
 pub mod wasix;
 
+use bincode::config;
 use bytes::{Buf, BufMut};
 use futures::{
-    future::{BoxFuture, LocalBoxFuture},
     Future,
+    future::{BoxFuture, LocalBoxFuture},
 };
 use tracing::instrument;
+use virtual_mio::block_on;
 pub use wasi::*;
 pub use wasix::*;
 use wasmer_journal::SnapshotTrigger;
@@ -36,7 +43,7 @@ pub mod legacy;
 pub(crate) use std::{
     borrow::{Borrow, Cow},
     cell::RefCell,
-    collections::{hash_map::Entry, HashMap, HashSet},
+    collections::{HashMap, HashSet, hash_map::Entry},
     convert::{Infallible, TryInto},
     io::{self, Read, Seek, Write},
     mem::transmute,
@@ -46,8 +53,9 @@ pub(crate) use std::{
     path::Path,
     pin::Pin,
     sync::{
+        Arc, Condvar, Mutex,
         atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
-        mpsc, Arc, Condvar, Mutex,
+        mpsc,
     },
     task::{Context, Poll},
     thread::LocalKey,
@@ -85,24 +93,40 @@ 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,
     },
     *,
 };
 use self::{
-    state::{conv_env_vars, WasiInstanceGuardMemory},
+    state::{WasiInstanceGuardMemory, conv_env_vars},
     utils::WasiDummyWaker,
 };
 pub(crate) use crate::os::task::{
     process::{WasiProcessId, WasiProcessWait},
     thread::{WasiThread, WasiThreadId},
 };
+use crate::{
+    DeepSleepWork, RewindPostProcess, RewindState, RewindStateOption, SpawnError, WasiInodes,
+    WasiResult, WasiRuntimeError,
+    fs::{
+        Fd, FdInner, InodeVal, Kind, MAX_SYMLINKS, fs_error_into_wasi_err,
+        virtual_file_type_to_wasi_file_type,
+    },
+    journal::{DynJournal, DynReadableJournal, DynWritableJournal, JournalEffector},
+    os::task::{
+        process::{MaybeCheckpointResult, WasiProcessCheckpoint},
+        thread::{RewindResult, RewindResultType},
+    },
+    utils::store::StoreSnapshot,
+};
 pub(crate) use crate::{
+    Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiModuleTreeHandles,
+    WasiVFork,
     bin_factory::spawn_exec_module,
     import_object_for_all_wasi_versions, mem_error_to_wasi,
     net::{
@@ -110,29 +134,12 @@ 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,
+        self, InodeGuard, InodeWeakGuard, PollEvent, PollEventBuilder, WasiFutex, WasiState,
+        iterate_poll_events,
     },
     utils::{self, map_io_err},
-    Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiInstanceHandles,
-    WasiVFork,
-};
-use crate::{
-    fs::{
-        fs_error_into_wasi_err, virtual_file_type_to_wasi_file_type, Fd, InodeVal, Kind,
-        MAX_SYMLINKS,
-    },
-    journal::{DynJournal, JournalEffector},
-    os::task::{
-        process::{MaybeCheckpointResult, WasiProcessCheckpoint},
-        thread::{RewindResult, RewindResultType},
-    },
-    runtime::task_manager::InlineWaker,
-    utils::store::StoreSnapshot,
-    DeepSleepWork, RewindPostProcess, RewindState, RewindStateOption, SpawnError, WasiInodes,
-    WasiResult, WasiRuntimeError,
 };
 pub(crate) use crate::{net::net_error_into_wasi_err, utils::WasiParkingLot};
 
@@ -233,23 +240,19 @@ 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>,
     buf: &[u8],
 ) -> LocalBoxFuture<'a, Result<(), Errno>> {
     let env = ctx.data();
-    let (memory, state, inodes) = env.get_memory_and_wasi_state_and_inodes(ctx, 0);
+    let (memory, state, inodes) = unsafe { 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>(
@@ -297,7 +300,7 @@ where
     }
 
     // Slow path, block on the work and process process
-    InlineWaker::block_on(work)
+    block_on(work)
 }
 
 /// Asyncify takes the current thread and blocks on the async runtime associated with it
@@ -328,7 +331,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 +370,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 +381,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 +415,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 +505,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
@@ -539,7 +548,7 @@ where
                     let result = trigger.await;
                     tracing::trace!(%pid, %tid, "thread leaving deep sleep");
                     thread.set_deep_sleeping(false);
-                    bincode::serialize(&result).unwrap().into()
+                    bincode::serde::encode_to_vec(&result, config::legacy()).unwrap().into()
                 }))?;
                 AsyncifyAction::Unwind
             },
@@ -548,7 +557,7 @@ where
 
     // Block until the work is finished or until we
     // unload the thread using asyncify
-    InlineWaker::block_on(work)
+    block_on(work)
 }
 
 /// Asyncify takes the current thread and blocks on the async runtime associated with it
@@ -557,7 +566,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,40 +575,9 @@ 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))
+    Ok(block_on(work))
 }
 
 // This should be compiled away, it will simply wait forever however its never
@@ -627,7 +605,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);
     }
 
@@ -652,7 +630,7 @@ where
 
     // Block until the work is finished or until we
     // unload the thread using asyncify
-    InlineWaker::block_on(work)
+    block_on(work)
 }
 
 /// Performs mutable work on a socket under an asynchronous runtime with
@@ -671,7 +649,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);
     }
 
@@ -688,7 +666,7 @@ where
 
             // Otherwise we block on the work and process it
             // using an asynchronou context
-            InlineWaker::block_on(work)
+            block_on(work)
         }
         _ => Err(Errno::Notsock),
     }
@@ -710,7 +688,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 +725,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 +759,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,10 +780,10 @@ 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);
+                let res = block_on(work);
                 let new_socket = res?;
 
                 if let Some(mut new_socket) = new_socket {
@@ -862,10 +840,10 @@ pub(crate) fn write_buffer_array<M: MemorySize>(
         let data =
             wasi_try_mem!(new_ptr.slice(memory, wasi_try!(to_offset::<M>(sub_buffer.len()))));
         wasi_try_mem!(data.write_slice(sub_buffer));
-        wasi_try_mem!(wasi_try_mem!(
-            new_ptr.add_offset(wasi_try!(to_offset::<M>(sub_buffer.len())))
-        )
-        .write(memory, 0));
+        wasi_try_mem!(
+            wasi_try_mem!(new_ptr.add_offset(wasi_try!(to_offset::<M>(sub_buffer.len()))))
+                .write(memory, 0)
+        );
 
         current_buffer_offset += sub_buffer.len() + 1;
     }
@@ -892,14 +870,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)
 }
@@ -908,7 +892,7 @@ pub(crate) unsafe fn get_memory_stack_offset(
     ctx: &mut FunctionEnvMut<'_, WasiEnv>,
 ) -> Result<u64, String> {
     let stack_upper = get_stack_upper(ctx.data());
-    let stack_pointer = get_memory_stack_pointer(ctx)?;
+    let stack_pointer = unsafe { get_memory_stack_pointer(ctx) }?;
     Ok(stack_upper - stack_pointer)
 }
 
@@ -921,8 +905,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 +925,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 +939,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 +950,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 +972,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 +1002,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 +1038,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 +1106,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))),
     }
 }
 
@@ -1158,22 +1142,24 @@ where
         unwind_pointer + (std::mem::size_of::<__wasi_asyncify_t<M::Offset>>() as u64);
     let unwind_data = __wasi_asyncify_t::<M::Offset> {
         start: wasi_try_ok!(unwind_data_start.try_into().map_err(|_| Errno::Overflow)),
-        end: wasi_try_ok!((env.layout.stack_upper - memory_stack.len() as u64)
-            .try_into()
-            .map_err(|_| Errno::Overflow)),
+        end: wasi_try_ok!(
+            (env.layout.stack_upper - memory_stack.len() as u64)
+                .try_into()
+                .map_err(|_| Errno::Overflow)
+        ),
     };
-    let unwind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> =
-        WasmPtr::new(wasi_try_ok!(unwind_pointer
-            .try_into()
-            .map_err(|_| Errno::Overflow)));
+    let unwind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> = WasmPtr::new(wasi_try_ok!(
+        unwind_pointer.try_into().map_err(|_| Errno::Overflow)
+    ));
     wasi_try_mem_ok!(unwind_data_ptr.write(&memory, unwind_data));
 
     // 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 +1219,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 +1240,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,
@@ -1267,17 +1252,19 @@ pub fn rewind<M: MemorySize, T>(
 where
     T: serde::Serialize,
 {
-    let rewind_result = bincode::serialize(&result).unwrap().into();
+    let rewind_result = bincode::serde::encode_to_vec(&result, config::legacy())
+        .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>,
@@ -1324,40 +1311,43 @@ pub fn rewind_ext<M: MemorySize>(
     }
     let rewind_data = __wasi_asyncify_t::<M::Offset> {
         start: wasi_try!(rewind_data_end.try_into().map_err(|_| Errno::Overflow)),
-        end: wasi_try!(env
-            .layout
-            .stack_upper
-            .try_into()
-            .map_err(|_| Errno::Overflow)),
+        end: wasi_try!(
+            env.layout
+                .stack_upper
+                .try_into()
+                .map_err(|_| Errno::Overflow)
+        ),
     };
-    let rewind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> =
-        WasmPtr::new(wasi_try!(rewind_pointer
-            .try_into()
-            .map_err(|_| Errno::Overflow)));
+    let rewind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> = WasmPtr::new(wasi_try!(
+        rewind_pointer.try_into().map_err(|_| Errno::Overflow)
+    ));
     wasi_try_mem!(rewind_data_ptr.write(&memory, rewind_data));
 
     // Copy the data to the address
-    let rewind_stack_ptr = WasmPtr::<u8, M>::new(wasi_try!(rewind_data_start
-        .try_into()
-        .map_err(|_| Errno::Overflow)));
-    wasi_try_mem!(rewind_stack_ptr
-        .slice(
-            &memory,
-            wasi_try!(rewind_stack.len().try_into().map_err(|_| Errno::Overflow))
-        )
-        .and_then(|stack| { stack.write_slice(&rewind_stack[..]) }));
+    let rewind_stack_ptr = WasmPtr::<u8, M>::new(wasi_try!(
+        rewind_data_start.try_into().map_err(|_| Errno::Overflow)
+    ));
+    wasi_try_mem!(
+        rewind_stack_ptr
+            .slice(
+                &memory,
+                wasi_try!(rewind_stack.len().try_into().map_err(|_| Errno::Overflow))
+            )
+            .and_then(|stack| { stack.write_slice(&rewind_stack[..]) })
+    );
 
     // 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 {
-        warn!("failed to rewind the stack because the asyncify_start_rewind export is missing or inaccessible");
+        warn!(
+            "failed to rewind the stack because the asyncify_start_rewind export is missing or inaccessible"
+        );
         return Errno::Noexec;
     }
 
@@ -1408,7 +1398,7 @@ pub(crate) unsafe fn handle_rewind<M: MemorySize, T>(
 where
     T: serde::de::DeserializeOwned,
 {
-    handle_rewind_ext::<M, T>(ctx, HandleRewindType::ResultDriven).flatten()
+    unsafe { handle_rewind_ext::<M, T>(ctx, HandleRewindType::ResultDriven) }.flatten()
 }
 
 pub(crate) enum HandleRewindType {
@@ -1426,7 +1416,7 @@ pub(crate) unsafe fn handle_rewind_ext_with_default<M: MemorySize, T>(
 where
     T: serde::de::DeserializeOwned + Default,
 {
-    let ret = handle_rewind_ext::<M, T>(ctx, type_);
+    let ret = unsafe { handle_rewind_ext::<M, T>(ctx, type_) };
     ret.unwrap_or_default()
 }
 
@@ -1451,10 +1441,16 @@ 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");
+            warn!(
+                "failed to handle rewind because the asyncify_start_rewind export is missing or inaccessible"
+            );
             return Some(None);
         }
 
@@ -1466,22 +1462,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());
-                let ret = bincode::deserialize(&rewind_result)
+                tracing::trace!(%pid, %tid, "rewind with result (data={})", rewind_result.len());
+                let (ret, _) = bincode::serde::decode_from_slice(&rewind_result, config::legacy())
                     .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 +1487,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 +1526,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/unix/mod.rs b/lib/wasix/src/syscalls/unix/mod.rs
index 11b6bd143f..b28e6e3f52 100644
--- a/lib/wasix/src/syscalls/unix/mod.rs
+++ b/lib/wasix/src/syscalls/unix/mod.rs
@@ -1,8 +1,8 @@
 use std::mem;
 
 use libc::{
-    clock_getres, clock_gettime, timespec, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID,
-    CLOCK_REALTIME, CLOCK_THREAD_CPUTIME_ID,
+    CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, CLOCK_REALTIME, CLOCK_THREAD_CPUTIME_ID,
+    clock_getres, clock_gettime, timespec,
 };
 use wasmer::WasmRef;
 use wasmer_wasix_types::wasi::{Errno, Snapshot0Clockid, Timestamp};
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..48aeec31a0 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,16 @@ 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..2a77e9a4e6 100644
--- a/lib/wasix/src/syscalls/wasi/clock_time_get.rs
+++ b/lib/wasix/src/syscalls/wasi/clock_time_get.rs
@@ -6,14 +6,18 @@ use crate::syscalls::*;
 
 /// ### `clock_time_get()`
 /// Get the time of the specified clock
+///
 /// Inputs:
+///
 /// - `Clockid clock_id`
-///     The ID of the clock to query
+///   The ID of the clock to query
 /// - `Timestamp precision`
-///     The maximum amount of error the reading may have
+///   The maximum amount of error the reading may have
+///
 /// Output:
+///
 /// - `Timestamp *time`
-///     The value of the clock in nanoseconds
+///   The value of the clock in nanoseconds
 #[cfg_attr(
     feature = "extra-logging",
     tracing::instrument(level = "trace", skip_all, ret)
@@ -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/environ_sizes_get.rs b/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs
index 73f4dddd9a..304762f306 100644
--- a/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs
+++ b/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs
@@ -25,13 +25,15 @@ pub fn environ_sizes_get<M: MemorySize>(
     let environ_count = environ_count.deref(&memory);
     let environ_buf_size = environ_buf_size.deref(&memory);
 
-    let env_var_count: M::Offset = wasi_try_ok!(state
-        .envs
-        .lock()
-        .unwrap()
-        .len()
-        .try_into()
-        .map_err(|_| Errno::Overflow));
+    let env_var_count: M::Offset = wasi_try_ok!(
+        state
+            .envs
+            .lock()
+            .unwrap()
+            .len()
+            .try_into()
+            .map_err(|_| Errno::Overflow)
+    );
     let env_buf_size: usize = state.envs.lock().unwrap().iter().map(|v| v.len() + 1).sum();
     let env_buf_size: M::Offset =
         wasi_try_ok!(env_buf_size.try_into().map_err(|_| Errno::Overflow));
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..17b6162ec3 100644
--- a/lib/wasix/src/syscalls/wasi/fd_close.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_close.rs
@@ -12,31 +12,39 @@ 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)
+        && !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..cebf193be1 100644
--- a/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
@@ -4,36 +4,46 @@ 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
+///   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)]
+///   Where the metadata from `fd` will be written
+#[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
+///   The open file descriptor whose metadata will be read
+///
 /// Output:
 /// - `__wasi_filestat_t *buf`
-///     Where the metadata from `fd` will be written
+///   Where the metadata from `fd` will be written
 pub(crate) fn fd_filestat_get_internal(
     ctx: &mut FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
@@ -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
+///   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)]
+///   Where the metadata from `fd` will be written
+#[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..2748e578f2 100644
--- a/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
@@ -13,22 +13,24 @@ 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?
 
     let guard = inode.read();
     match guard.deref() {
         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 {
-                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));
-
-                //trace!("=> result: \"{}\"", inode_val.name);
+            let name_len = name.len() as u64;
+            if name_len <= path_len {
+                wasi_try_mem!(
+                    path_chars
+                        .subslice(0..name_len)
+                        .write_slice(name.as_bytes())
+                );
+                // Note: We don't write a null terminator since WASI spec doesn't require it
+                // and pr_name_len already gives the exact length
 
                 Errno::Success
             } else {
@@ -39,7 +41,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..20fa956f77 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,26 +47,34 @@ 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))
-                    .collect::<Result<Vec<_>, _>>()
-                    .map_err(fs_error_into_wasi_err));
-                let mut entry_vec = wasi_try!(fs_info
-                    .into_iter()
-                    .map(|entry| {
-                        let filename = entry.file_name().to_string_lossy().to_string();
-                        trace!("getting file: {:?}", filename);
-                        let filetype = virtual_file_type_to_wasi_file_type(
-                            entry.file_type().map_err(fs_error_into_wasi_err)?,
-                        );
-                        Ok((
-                            filename, filetype, 0, // TODO: inode
-                        ))
-                    })
-                    .collect::<Result<Vec<(String, Filetype, u64)>, _>>());
+                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_ok!(
+                    fs_info
+                        .into_iter()
+                        .map(|entry| {
+                            let filename = entry.file_name().to_string_lossy().to_string();
+                            trace!("getting file: {:?}", filename);
+                            let filetype = virtual_file_type_to_wasi_file_type(
+                                entry.file_type().map_err(fs_error_into_wasi_err)?,
+                            );
+                            Ok((
+                                filename, filetype, 0, // TODO: inode
+                            ))
+                        })
+                        .collect::<Result<Vec<(String, Filetype, u64)>, _>>()
+                );
                 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 +98,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 +110,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 +135,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 +143,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 +151,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..5723cf9389 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 {
@@ -79,11 +76,13 @@ pub(crate) fn fd_seek_internal(
             } else if offset < 0 {
                 let offset = offset.unsigned_abs();
 
-                wasi_try_ok_ok!(fd_entry
-                    .offset
-                    .fetch_sub(offset, Ordering::AcqRel)
-                    .checked_sub(offset)
-                    .ok_or(Errno::Inval))
+                wasi_try_ok_ok!(
+                    fd_entry
+                        .offset
+                        .fetch_sub(offset, Ordering::AcqRel)
+                        .checked_sub(offset)
+                        .ok_or(Errno::Inval)
+                )
             } else {
                 fd_entry.offset.load(Ordering::Acquire)
             }
@@ -93,7 +92,7 @@ pub(crate) fn fd_seek_internal(
             let mut guard = fd_entry.inode.write();
             let deref_mut = guard.deref_mut();
             match deref_mut {
-                Kind::File { ref mut handle, .. } => {
+                Kind::File { handle, .. } => {
                     // TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
                     #[allow(clippy::await_holding_lock)]
                     if let Some(handle) = handle {
@@ -110,7 +109,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 +123,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 +137,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..d5bcd3bc71 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,35 +275,121 @@ 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 iovs_arr = wasi_try_ok_ok!(iovs
-                                .slice(&memory, *iovs_len)
-                                .map_err(mem_error_to_wasi));
+                            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!(
+                                    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 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();
                         }
                     }
@@ -311,25 +405,26 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
 
                     match &data {
                         FdWriteSource::Iovs { iovs, iovs_len } => {
-                            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.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_len: usize = wasi_try_ok_ok!(iovs
-                                    .buf_len
-                                    .try_into()
-                                    .map_err(|_| Errno::Inval));
+                                let buf_len: usize = wasi_try_ok_ok!(
+                                    iovs.buf_len.try_into().map_err(|_| Errno::Inval)
+                                );
                                 let will_be_written = buf_len;
 
                                 let val_cnt = buf_len / std::mem::size_of::<u64>();
                                 let val_cnt: M::Offset =
                                     wasi_try_ok_ok!(val_cnt.try_into().map_err(|_| Errno::Inval));
 
-                                let vals = wasi_try_ok_ok!(WasmPtr::<u64, M>::new(iovs.buf)
-                                    .slice(&memory, val_cnt as M::Offset)
-                                    .map_err(mem_error_to_wasi));
+                                let vals = wasi_try_ok_ok!(
+                                    WasmPtr::<u64, M>::new(iovs.buf)
+                                        .slice(&memory, val_cnt as M::Offset)
+                                        .map_err(mem_error_to_wasi)
+                                );
                                 let vals =
                                     wasi_try_ok_ok!(vals.access().map_err(mem_error_to_wasi));
                                 for val in vals.iter() {
@@ -366,19 +461,21 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
 
                     match &data {
                         FdWriteSource::Iovs { iovs, iovs_len } => {
-                            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.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!(
+                                    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 local_written =
-                                    wasi_try_ok_ok!(std::io::Write::write(buffer, buf.as_ref())
-                                        .map_err(map_io_err));
+                                let local_written = wasi_try_ok_ok!(
+                                    std::io::Write::write(buffer, buf.as_ref()).map_err(map_io_err)
+                                );
                                 written += local_written;
                                 if local_written != buf.len() {
                                     break;
@@ -399,14 +496,16 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
         };
 
         #[cfg(feature = "journal")]
-        if should_snapshot && can_snapshot && bytes_written > 0 {
-            if let FdWriteSource::Iovs { iovs, iovs_len } = data {
-                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))
-                    })?;
-            }
+        if should_snapshot
+            && can_snapshot
+            && bytes_written > 0
+            && let FdWriteSource::Iovs { iovs, iovs_len } = data
+        {
+            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::from(Errno::Fault))
+                })?;
         }
 
         env = ctx.data();
@@ -417,14 +516,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/mod.rs b/lib/wasix/src/syscalls/wasi/mod.rs
index f336026778..68d7f420c8 100644
--- a/lib/wasix/src/syscalls/wasi/mod.rs
+++ b/lib/wasix/src/syscalls/wasi/mod.rs
@@ -86,4 +86,4 @@ pub use proc_raise::*;
 pub use random_get::*;
 pub use thread_spawn::*;
 
-use tracing::{debug_span, field, instrument, trace_span, Span};
+use tracing::{Span, debug_span, field, instrument, trace_span};
diff --git a/lib/wasix/src/syscalls/wasi/path_create_directory.rs b/lib/wasix/src/syscalls/wasi/path_create_directory.rs
index 99944f7992..6625317b91 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,77 @@ 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 { entries, 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 { 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..c1ea391b20 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: 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..4b41ad991b 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,19 +67,21 @@ 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
-    wasi_try_ok!(state
-        .fs
-        .get_inode_at_path(inodes, source_fd, source_path, true));
+    // 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)
+    );
     // Create the destination inode if the file exists.
     let _ = state
         .fs
@@ -100,13 +106,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 +130,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);
@@ -139,7 +147,7 @@ pub fn path_rename_internal(
     {
         let mut guard = source_entry.write();
         match guard.deref_mut() {
-            Kind::File { ref path, .. } => {
+            Kind::File { path, .. } => {
                 let result = {
                     let path_clone = path.clone();
                     drop(guard);
@@ -159,17 +167,15 @@ 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 { path, .. } = guard.deref_mut() {
+                        *path = host_adjusted_target_path;
+                    } else {
+                        unreachable!()
                     }
                 }
             }
-            Kind::Dir { ref path, .. } => {
+            Kind::Dir { path, .. } => {
                 let cloned_path = path.clone();
                 let res = {
                     let state = state;
@@ -184,27 +190,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 +220,43 @@ 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 { path, .. } => {
+            *path = adjust_path(path, source_dir_path, target_dir_path);
+            return;
+        }
+        Kind::Dir { 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..617182fd51 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 { .. } => {
@@ -125,10 +127,7 @@ pub fn path_symlink_internal(
 
     {
         let mut guard = target_parent_inode.write();
-        if let Kind::Dir {
-            ref mut entries, ..
-        } = guard.deref_mut()
-        {
+        if let Kind::Dir { entries, .. } = guard.deref_mut() {
             entries.insert(entry_name, new_inode);
         }
     }
diff --git a/lib/wasix/src/syscalls/wasi/path_unlink_file.rs b/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
index c79a5812c3..712640708b 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();
 
@@ -69,9 +66,7 @@ pub(crate) fn path_unlink_file_internal(
     let removed_inode = {
         let mut guard = parent_inode.write();
         match guard.deref_mut() {
-            Kind::Dir {
-                ref mut entries, ..
-            } => {
+            Kind::Dir { entries, .. } => {
                 let removed_inode = wasi_try_ok!(entries.remove(&childs_name).ok_or(Errno::Inval));
                 // TODO: make this a debug assert in the future
                 assert!(inode.ino() == removed_inode.ino());
diff --git a/lib/wasix/src/syscalls/wasi/poll_oneoff.rs b/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
index dddf274c0a..b38064908f 100644
--- a/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
+++ b/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
@@ -3,10 +3,10 @@ use wasmer_wasix_types::wasi::{Subclockflags, SubscriptionClock, Userdata};
 
 use super::*;
 use crate::{
+    WasiInodes,
     fs::{InodeValFilePollGuard, InodeValFilePollGuardJoin},
     state::PollEventSet,
     syscalls::*,
-    WasiInodes,
 };
 
 /// An event that occurred.
@@ -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,12 @@ 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)?;
+
+    // An empty subscription list would otherwise block forever in the poll loop.
+    if nsubscriptions == M::ZERO {
+        return Ok(Errno::Inval);
+    }
 
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
@@ -95,7 +102,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 +184,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,16 +205,18 @@ 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
+///   The events to subscribe to
 /// - `__wasi_event_t *out`
-///     The events that have occured
+///   The events that have occured
 /// - `u32 nsubscriptions`
-///     The number of subscriptions and the number of events
+///   The number of subscriptions and the number of events
+///
 /// Output:
 /// - `u32 nevents`
-///     The number of events seen
+///   The number of events seen
 pub(crate) fn poll_oneoff_internal<'a, M: MemorySize, After>(
     mut ctx: FunctionEnvMut<'a, WasiEnv>,
     mut subs: Vec<(Option<WasiFd>, PollEventSet, Subscription)>,
@@ -252,7 +261,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 +281,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);
                         }
                     }
@@ -311,8 +324,11 @@ where
                                 1
                             )) as u64;
 
-                            Duration::from_nanos(clock_info.timeout)
-                                - Duration::from_nanos(now as u64)
+                            if clock_info.timeout <= now {
+                                Duration::ZERO
+                            } else {
+                                Duration::from_nanos(clock_info.timeout) - Duration::from_nanos(now)
+                            }
                         } else {
                             // if the timeout is not absolute, just use it as duration
                             Duration::from_nanos(clock_info.timeout)
@@ -326,7 +342,7 @@ where
                     return Ok(Errno::Inval);
                 }
             }
-            Eventtype::Unknown => {
+            _ => {
                 continue;
             }
         };
@@ -353,9 +369,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 +403,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 +415,7 @@ where
                 };
                 Span::current().record(
                     "seen",
-                    &format!(
+                    format!(
                         "clock(id={},userdata={})",
                         clock_info.clock_id as u32, evt.userdata
                     ),
@@ -451,9 +467,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..f4d22115e6 100644
--- a/lib/wasix/src/syscalls/wasi/proc_exit.rs
+++ b/lib/wasix/src/syscalls/wasi/proc_exit.rs
@@ -8,51 +8,30 @@ 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> {
-    debug!(%code);
+    let in_asyncify_based_vfork = ctx
+        .data()
+        .vfork
+        .as_ref()
+        .map(|v| v.asyncify.is_some())
+        .unwrap_or(false);
 
-    // 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() {
-        // 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 child_env = *vfork.env;
-        child_env.owned_handles.push(vfork.handle);
+    proc_exit2::<M>(ctx, code)?;
 
-        // Terminate the child process
-        child_env.process.terminate(code);
+    // proc_exit2 returns in two cases:
+    // 1. We are in an asyncify-based vfork, in which case on_called is set and magic will happen
+    // 2. We are in a setjmp/longjmp vfork, in which case we need to error out as returning from proc_exit is not allowed
 
-        // 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,
-                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())))
-                }
-            }
-        })?;
+    if in_asyncify_based_vfork {
         return Ok(());
     }
 
-    // Otherwise just exit
-    Err(WasiError::Exit(code))
+    tracing::error!(
+        "Calling proc_exit in a vfork is undefined behaviour. Call _exit or _proc_exit2 instead."
+    );
+    Err(WasiError::Exit(ExitCode::from(129)))
 }
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..5762f18148
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/call_dynamic.rs
@@ -0,0 +1,173 @@
+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"),
+    }
+}
+
+/// 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(crate::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..a50bf14077
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/closure_prepare.rs
@@ -0,0 +1,392 @@
+//! 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::{FunctionType, Table, Type, imports};
+
+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),
+            _ => Err(Errno::Inval),
+        }
+    }
+    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/context_create.rs b/lib/wasix/src/syscalls/wasix/context_create.rs
new file mode 100644
index 0000000000..896b67ed19
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/context_create.rs
@@ -0,0 +1,105 @@
+use crate::{WasiEnv, WasiError};
+use futures::FutureExt;
+use tracing::instrument;
+use wasmer::{
+    AsStoreRef, Function, FunctionEnvMut, MemorySize, RuntimeError, StoreMut, TypedFunction, Value,
+    WasmPtr,
+};
+use wasmer_wasix_types::wasi::Errno;
+
+/// Return the function corresponding to the given entrypoint index if it exists and has the signature `() -> ()`
+pub fn lookup_typechecked_entrypoint(
+    data: &WasiEnv,
+    mut store: &mut StoreMut<'_>,
+    entrypoint_id: u32,
+) -> Result<Function, Errno> {
+    let entrypoint = match data
+        .inner()
+        .indirect_function_table_lookup(&mut store, entrypoint_id)
+    {
+        Ok(func) => func,
+        Err(e) => {
+            tracing::trace!(
+                "Failed to lookup entrypoint function {}: {:?}",
+                entrypoint_id,
+                e
+            );
+            return Err(Errno::Inval);
+        }
+    };
+
+    // TODO: Remove this check and return a TypedFunction once all backends support types
+    #[cfg(not(feature = "js"))]
+    {
+        let entrypoint_type = entrypoint.ty(&store);
+        if !entrypoint_type.params().is_empty() && !entrypoint_type.results().is_empty() {
+            tracing::trace!(
+                "Entrypoint function {entrypoint_id} has invalid signature: expected () -> (), got {:?} -> {:?}",
+                entrypoint_type.params(),
+                entrypoint_type.results()
+            );
+            return Err(Errno::Inval);
+        }
+    }
+
+    Ok(entrypoint)
+}
+
+/// Create a new context.
+///
+/// Creates a new context in the suspended state. On its first resumption,
+/// `entrypoint` is invoked within that context.
+///
+/// Refer to the wasix-libc [`wasix/context.h`] header for authoritative
+/// documentation.
+///
+/// [`wasix/context.h`]: https://github.com/wasix-org/wasix-libc/blob/main/libc-bottom-half/headers/public/wasix/context.h
+#[instrument(level = "trace", skip(ctx), ret)]
+pub fn context_create<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    new_context_ptr: WasmPtr<u64, M>,
+    entrypoint: u32,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    // Verify that we are in an async context
+    // We need to do this first, before we borrow the store mutably
+    let Some(async_store) = ctx.as_store_async() else {
+        tracing::warn!(
+            "The WASIX context-switching API is only available in engines supporting async execution"
+        );
+        return Ok(Errno::Notsup);
+    };
+
+    let (data, mut store) = ctx.data_and_store_mut();
+
+    // Get the context-switching environment
+    let Some(environment) = &data.context_switching_environment else {
+        tracing::warn!(
+            "The WASIX context-switching API is only available in a context-switching environment"
+        );
+        return Ok(Errno::Notsup);
+    };
+
+    // Lookup and check the entrypoint function
+    let entrypoint = match lookup_typechecked_entrypoint(data, &mut store, entrypoint) {
+        Ok(func) => func,
+        Err(err) => {
+            return Ok(err);
+        }
+    };
+
+    // Create the new context
+    let new_context_id = environment.create_context(
+        entrypoint
+            .call_async(&async_store, vec![])
+            .map(|r| r.map(|_| ())),
+    );
+
+    // Write the new context ID into memory
+    let memory = unsafe { data.memory_view(&store) };
+    wasi_try_mem_ok!(new_context_ptr.write(&memory, new_context_id));
+
+    // Return success
+    return Ok(Errno::Success);
+}
diff --git a/lib/wasix/src/syscalls/wasix/context_destroy.rs b/lib/wasix/src/syscalls/wasix/context_destroy.rs
new file mode 100644
index 0000000000..f7367c6810
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/context_destroy.rs
@@ -0,0 +1,71 @@
+use crate::{WasiEnv, WasiError};
+use tracing::instrument;
+use wasmer::{AsStoreRef, FunctionEnvMut, MemoryView};
+use wasmer_wasix_types::wasi::Errno;
+
+/// Destroy a suspended or terminated context
+///
+/// After a successful call its identifier becomes invalid and its
+/// resources are released. Destroying an already deleted context is a no-op.
+///
+/// Refer to the wasix-libc [`wasix/context.h`] header for authoritative
+/// documentation.
+///
+/// [`wasix/context.h`]: https://github.com/wasix-org/wasix-libc/blob/main/libc-bottom-half/headers/public/wasix/context.h
+#[instrument(level = "trace", skip(ctx), ret)]
+pub fn context_destroy(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    target_context_id: u64,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let env = ctx.data();
+    let memory: MemoryView<'_> = unsafe { env.memory_view(&ctx) };
+
+    // Verify that we are in an async context
+    let environment = match &env.context_switching_environment {
+        Some(c) => c,
+        None => {
+            tracing::warn!(
+                "The WASIX context-switching API is only available in a context-switching environment"
+            );
+            return Ok(Errno::Notsup);
+        }
+    };
+
+    let own_context_id = environment.active_context_id();
+    let main_context_id = environment.main_context_id();
+
+    if own_context_id == target_context_id {
+        tracing::trace!(
+            "Context {} tried to delete itself, which is not allowed",
+            target_context_id
+        );
+        return Ok(Errno::Inval);
+    }
+
+    if target_context_id == main_context_id {
+        tracing::trace!(
+            "Context {} tried to delete the main context, which is not allowed",
+            own_context_id
+        );
+        return Ok(Errno::Inval);
+    }
+
+    let removed_unblocker = environment.destroy_context(&target_context_id);
+    // As soon as the Sender is dropped, the corresponding context will be able unblocked,
+    // the executor will continue executing it. The context will respond to the
+    // cancelation by terminating gracefully.
+
+    if !removed_unblocker {
+        // Context did not exist, so we do not need to remove it
+        tracing::trace!(
+            "Context {} tried to delete context {} but it is already removed",
+            own_context_id,
+            target_context_id
+        );
+        return Ok(Errno::Success);
+    };
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/context_switch.rs b/lib/wasix/src/syscalls/wasix/context_switch.rs
new file mode 100644
index 0000000000..a291aeeb15
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/context_switch.rs
@@ -0,0 +1,94 @@
+use crate::{WasiEnv, WasiError, state::context_switching::ContextSwitchError};
+use futures::FutureExt;
+use tracing::instrument;
+use wasmer::{AsyncFunctionEnvMut, FunctionEnvMut, RuntimeError};
+use wasmer_wasix_types::wasi::Errno;
+
+/// Suspend the active context and resume another
+///
+/// The resumed context continues from where it was last suspended, or from its
+/// entrypoint if it has never been resumed.
+///
+/// Refer to the wasix-libc [`wasix/context.h`] header for authoritative
+/// documentation.
+///
+/// [`wasix/context.h`]: https://github.com/wasix-org/wasix-libc/blob/main/libc-bottom-half/headers/public/wasix/context.h
+#[instrument(level = "trace", skip(ctx))]
+pub async fn context_switch(
+    mut ctx: AsyncFunctionEnvMut<WasiEnv>,
+    target_context_id: u64,
+) -> Result<Errno, RuntimeError> {
+    let mut write_lock = ctx.write().await;
+
+    let mut sync_env = write_lock.as_function_env_mut();
+    match WasiEnv::do_pending_operations(&mut sync_env) {
+        Ok(()) => {}
+        Err(e) => {
+            return Err(RuntimeError::user(e.into()));
+        }
+    }
+
+    let data = write_lock.data_mut();
+
+    // Verify that we are in an async context
+    let environment = match &data.context_switching_environment {
+        Some(c) => c,
+        None => {
+            tracing::warn!(
+                "The WASIX context-switching API is only available after entering the main function"
+            );
+            return Ok(Errno::Notsup);
+        }
+    };
+
+    // Get own context ID
+    let active_context_id = environment.active_context_id();
+
+    // If switching to self, do nothing
+    if active_context_id == target_context_id {
+        tracing::trace!("Switching context {active_context_id} to itself, which is a no-op");
+        return Ok(Errno::Success);
+    }
+
+    // Try to unblock the target and get future to wait until we are unblocked again
+    //
+    // We must be careful not to return after this point without awaiting the resulting future
+    let wait_for_unblock = match environment.switch_context(target_context_id) {
+        Ok(wait_for_unblock) => wait_for_unblock,
+        Err(ContextSwitchError::SwitchTargetMissing) => {
+            tracing::trace!(
+                "Context {active_context_id} tried to switch to context {target_context_id} but it does not exist or is not suspended"
+            );
+            return Ok(Errno::Inval);
+        }
+    };
+
+    // Drop the write lock before we suspend ourself, as that would cause a deadlock
+    drop(write_lock);
+    tracing::trace!("Suspending context {active_context_id} to switch to {target_context_id}");
+
+    // Wait until we are unblocked again
+    let result = wait_for_unblock.map(|v| v.map(|_| Errno::Success)).await;
+    tracing::trace!("Resumed context {active_context_id} after being switched back to");
+    if let Err(e) = &result {
+        tracing::trace!("But it has an error {e:?}");
+    }
+    result
+}
+
+/// This stub is used for context_switch, when the engine does not support async
+///
+/// It prints a warning and indicates that no context-switching environment is available.
+#[instrument(level = "trace", skip(ctx))]
+pub fn context_switch_not_supported(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    _target_context_id: u64,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    tracing::warn!(
+        "The WASIX context-switching API is only available in engines supporting async execution"
+    );
+    // Indicate that no context-switching environment is available
+    Ok(Errno::Notsup)
+}
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..cc6c8d293d 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_create.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_create.rs
@@ -3,10 +3,10 @@ use wasmer_wasix_types::wasi::{SubscriptionClock, Userdata};
 
 use super::*;
 use crate::{
+    WasiInodes,
     fs::{InodeValFilePollGuard, InodeValFilePollGuardJoin},
     state::PollEventSet,
     syscalls::*,
-    WasiInodes,
 };
 use std::sync::Mutex as StdMutex;
 use tokio::sync::Mutex as AsyncMutex;
@@ -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..f6d0596d02 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
@@ -12,13 +12,13 @@ use futures::Future;
 
 use super::*;
 use crate::{
+    WasiInodes,
     fs::{
         EpollFd, EpollInterest, EpollJoinGuard, InodeValFilePollGuard, InodeValFilePollGuardJoin,
         InodeValFilePollGuardMode, POLL_GUARD_MAX_RET,
     },
     state::PollEventSet,
     syscalls::*,
-    WasiInodes,
 };
 
 /// ### `epoll_ctl()`
@@ -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))
         })?;
     }
 
@@ -93,43 +95,45 @@ pub(crate) fn epoll_ctl_internal(
 
                 tracing::trace!(fd, "unregistering waker");
             }
-            if let EpollCtl::Add | EpollCtl::Mod = op {
-                if let Some(event) = event_ctl {
-                    let epoll_fd = EpollFd {
-                        events: event.events,
-                        ptr: event.ptr,
-                        fd: event.fd,
-                        data1: event.data1,
-                        data2: event.data2,
-                    };
+            if let EpollCtl::Add | EpollCtl::Mod = op
+                && let Some(event) = event_ctl
+            {
+                let epoll_fd = EpollFd {
+                    events: event.events,
+                    ptr: event.ptr,
+                    fd: event.fd,
+                    data1: event.data1,
+                    data2: event.data2,
+                };
 
-                    // Output debug
-                    tracing::trace!(
-                        peb = ?event.events,
-                        ptr = ?event.ptr,
-                        data1 = event.data1,
-                        data2 = event.data2,
-                        fd = event.fd,
-                        "registering waker"
-                    );
+                // Output debug
+                tracing::trace!(
+                    peb = ?event.events,
+                    ptr = ?event.ptr,
+                    data1 = event.data1,
+                    data2 = event.data2,
+                    fd = event.fd,
+                    "registering waker"
+                );
 
-                    {
-                        // We have to register the subscription before we register the waker
-                        // as otherwise there is a race condition
-                        let mut guard = subscriptions.lock().unwrap();
-                        guard.insert(event.fd, (epoll_fd.clone(), Vec::new()));
-                    }
+                {
+                    // We have to register the subscription before we register the waker
+                    // as otherwise there is a race condition
+                    let mut guard = subscriptions.lock().unwrap();
+                    guard.insert(event.fd, (epoll_fd.clone(), Vec::new()));
+                }
 
-                    // 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));
+                // Now we register the epoll waker
+                let tx = tx.clone();
+                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);
-                    }
+                // 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)
+                    && let Some(fd_guard) = fd_guard
+                {
+                    subs.1.push(fd_guard);
                 }
             }
             Ok(Ok(()))
@@ -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..7d72ad7eb0 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_wait.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_wait.rs
@@ -5,10 +5,10 @@ use wasmer_wasix_types::wasi::{
 
 use super::*;
 use crate::{
+    WasiInodes,
     fs::{EpollFd, InodeValFilePollGuard, InodeValFilePollGuardJoin, POLL_GUARD_MAX_RET},
     state::PollEventSet,
     syscalls::*,
-    WasiInodes,
 };
 
 const TIMEOUT_FOREVER: u64 = u64::MAX;
@@ -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..ae2020df99 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;
@@ -26,10 +28,10 @@ pub fn futex_wake<M: MemorySize>(
         let mut guard = state.futexs.lock().unwrap();
         if let Some(futex) = guard.futexes.get_mut(&pointer) {
             let first = futex.wakers.keys().copied().next();
-            if let Some(id) = first {
-                if let Some(Some(w)) = futex.wakers.remove(&id) {
-                    w.wake();
-                }
+            if let Some(id) = first
+                && let Some(Some(w)) = futex.wakers.remove(&id)
+            {
+                w.wake();
             }
             if futex.wakers.is_empty() {
                 guard.futexes.remove(&pointer);
@@ -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..bc2bf061f5 100644
--- a/lib/wasix/src/syscalls/wasix/mod.rs
+++ b/lib/wasix/src/syscalls/wasix/mod.rs
@@ -1,13 +1,27 @@
+mod call_dynamic;
 mod callback_signal;
 mod chdir;
+mod closure_allocate;
+mod closure_free;
+mod closure_prepare;
+mod context_create;
+mod context_destroy;
+mod context_switch;
+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 +37,20 @@ mod port_route_remove;
 mod port_unbridge;
 mod proc_exec;
 mod proc_exec2;
+mod proc_exec3;
+mod proc_exit2;
 mod proc_fork;
+mod proc_fork_env;
 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 +67,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 +90,30 @@ 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 context_create::*;
+pub use context_destroy::*;
+pub use context_switch::*;
+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 +129,20 @@ pub use port_route_remove::*;
 pub use port_unbridge::*;
 pub use proc_exec::*;
 pub use proc_exec2::*;
+pub use proc_exec3::*;
+pub use proc_exit2::*;
 pub use proc_fork::*;
+pub use proc_fork_env::*;
 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 +159,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::*;
@@ -136,4 +182,4 @@ pub use thread_spawn::*;
 pub use tty_get::*;
 pub use tty_set::*;
 
-use tracing::{debug_span, field, instrument, trace_span, Span};
+use tracing::{Span, debug_span, field, instrument, trace_span};
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..dae3cdf1e3
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/path_open2.rs
@@ -0,0 +1,428 @@
+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 {
+                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::Isdir));
+                }
+            }
+            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 { 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..942da7afaa 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_list.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_list.rs
@@ -10,18 +10,22 @@ 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);
-    let max_routes: usize = wasi_try_ok!(wasi_try_mem_ok!(ref_nroutes.read())
-        .try_into()
-        .map_err(|_| Errno::Inval));
+    let max_routes: usize = wasi_try_ok!(
+        wasi_try_mem_ok!(ref_nroutes.read())
+            .try_into()
+            .map_err(|_| Errno::Inval)
+    );
     Span::current().record("max_routes", max_routes);
     let ref_routes =
         wasi_try_mem_ok!(routes_ptr.slice(&memory, wasi_try_ok!(to_offset::<M>(max_routes))));
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..91e06f955d
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_exec3.rs
@@ -0,0 +1,344 @@
+use wasmer::FromToNativeWasmType;
+
+use super::*;
+use crate::{
+    VIRTUAL_ROOT_FD, WasiFs,
+    os::task::{OwnedTaskStatus, TaskStatus},
+    syscalls::*,
+};
+
+/// 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);
+
+        // Record 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 child env back
+                child_env.swap_inner(ctx.data_mut());
+                std::mem::swap(child_env.as_mut(), ctx.data_mut());
+
+                // Put back the vfork we previously took from here
+                ctx.data_mut().vfork = Some(vfork);
+                return Ok(e);
+            }
+            Ok(()) => {
+                // We spawned a new process - put the parent env back
+                ctx.data_mut().swap_inner(&mut vfork.env);
+                std::mem::swap(ctx.data_mut(), &mut vfork.env);
+
+                assert!(vfork.env.context_switching_environment.is_none());
+                assert!(ctx.data().context_switching_environment.is_some());
+
+                let Some(asyncify_info) = vfork.asyncify else {
+                    // vfork without asyncify only forks the WasiEnv, which we have restored
+                    // above. Restoring the control flow is done on the guest side.
+                    // See `proc_fork_env()` for information about this.
+
+                    return Ok(Errno::Success);
+                };
+
+                // Jump back to the vfork point and continue execution
+                // note: fork does not return any values hence passing `()`
+                let rewind_stack = asyncify_info.rewind_stack.freeze();
+                let store_data = asyncify_info.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
+                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_exit2.rs b/lib/wasix/src/syscalls/wasix/proc_exit2.rs
new file mode 100644
index 0000000000..5ded2f05c7
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_exit2.rs
@@ -0,0 +1,80 @@
+use super::*;
+use crate::{WasiVForkAsyncify, syscalls::*};
+
+/// ### `proc_exit2()`
+/// Similar to `proc_exit()`
+///
+/// If used in a `proc_fork_env` (vfork) context it will exit the
+/// child, switch the process back into the parent process and
+/// return. If used for vforking, restoring the control to the
+/// place where the vfork happened is the responsibility of the
+/// caller.
+#[instrument(level = "trace", skip(ctx))]
+pub fn proc_exit2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    code: ExitCode,
+) -> Result<(), WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let Some(mut vfork) = ctx.data_mut().vfork.take() else {
+        // Not in a vfork, just exit normally
+        return Err(WasiError::Exit(code));
+    };
+
+    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
+    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
+    let mut parent_env = vfork.env;
+    ctx.data_mut().swap_inner(parent_env.as_mut());
+    let mut child_env = std::mem::replace(ctx.data_mut(), *parent_env);
+
+    // Terminate the child process
+    child_env.owned_handles.push(vfork.handle);
+    child_env.process.terminate(code);
+
+    let Some(asyncify_info) = vfork.asyncify else {
+        // vfork without asyncify only forks the WasiEnv, which we have restored
+        // above. We now return to the guest side in the parent process. Restoring
+        // the control flow is done on the guest side.
+        // See `proc_fork_env()` for information about this.
+
+        return Ok(());
+    };
+
+    // Jump back to the vfork point and continue execution
+    let child_pid = child_env.process.pid();
+    let rewind_stack = asyncify_info.rewind_stack.freeze();
+    let store_data = asyncify_info.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,
+            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(())
+}
diff --git a/lib/wasix/src/syscalls/wasix/proc_fork.rs b/lib/wasix/src/syscalls/wasix/proc_fork.rs
index 31092c86e5..0b282bec72 100644
--- a/lib/wasix/src/syscalls/wasix/proc_fork.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_fork.rs
@@ -1,10 +1,10 @@
 use super::*;
 use crate::{
-    capture_store_snapshot,
+    WasiThreadHandle, WasiVForkAsyncify, capture_store_snapshot,
     os::task::OwnedTaskStatus,
     runtime::task_manager::{TaskWasm, TaskWasmRunProperties},
+    state::context_switching::ContextSwitchingEnvironment,
     syscalls::*,
-    WasiThreadHandle,
 };
 use serde::{Deserialize, Serialize};
 use wasmer::Memory;
@@ -19,13 +19,28 @@ 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 let Some(context_switching_environment) = ctx.data().context_switching_environment.as_ref()
+        && context_switching_environment.active_context_id()
+            != context_switching_environment.main_context_id()
+    {
+        warn!(
+            "process forking is only supported from the main context when using WASIX context-switching features"
+        );
+        return Ok(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) } {
@@ -34,8 +49,7 @@ pub fn proc_fork<M: MemorySize>(
         } else {
             trace!(
                 "handle_rewind - i am parent (child={}, ret={})",
-                result.pid,
-                result.ret
+                result.pid, result.ret
             );
         }
         let memory = unsafe { ctx.data().memory_view(&ctx) };
@@ -44,6 +58,11 @@ pub fn proc_fork<M: MemorySize>(
     }
     trace!(%copy_memory, "capturing");
 
+    if let Some(vfork) = ctx.data().vfork.as_ref() {
+        warn!("process forking not supported in an active vfork");
+        return Ok(Errno::Notsup);
+    }
+
     // 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
@@ -94,20 +113,23 @@ pub fn proc_fork<M: MemorySize>(
             // if it had actually forked
             child_env.swap_inner(ctx.data_mut());
             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(),
+            let previous_vfork = ctx.data_mut().vfork.replace(WasiVFork {
+                asyncify: Some(WasiVForkAsyncify {
+                    rewind_stack: rewind_stack.clone(),
+                    store_data: store_data.clone(),
+                    is_64bit: M::is_64bit(),
+                }),
                 env: Box::new(child_env),
                 handle: child_handle,
             });
+            assert!(previous_vfork.is_none()); // Already checked above
 
             // Carry on as if the fork had taken place (which basically means
             // it prevents to be the new process with the old one suspended)
             // 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 +173,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 +198,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 +223,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 +240,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 {
@@ -260,17 +284,29 @@ fn run<M: MemorySize>(
     }
 
     let mut ret: ExitCode = Errno::Success.into();
-    let err = if ctx.data(&store).thread.is_main() {
+    let (mut store, err) = if ctx.data(&store).thread.is_main() {
         trace!(%pid, %tid, "re-invoking main");
-        let start = unsafe { ctx.data(&store).inner() }.start.clone().unwrap();
-        start.call(&mut store)
+        let start = ctx
+            .data(&store)
+            .inner()
+            .static_module_instance_handles()
+            .unwrap()
+            .start
+            .clone()
+            .unwrap();
+        ContextSwitchingEnvironment::run_main_context(&ctx, store, start.into(), vec![])
     } 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();
-        start.call(&mut store, 0, 0)
+        let params = vec![0i32.into(), 0i32.into()];
+        ContextSwitchingEnvironment::run_main_context(&ctx, store, start.into(), params)
     };
     if let Err(err) = err {
         match err.downcast::<WasiError>() {
diff --git a/lib/wasix/src/syscalls/wasix/proc_fork_env.rs b/lib/wasix/src/syscalls/wasix/proc_fork_env.rs
new file mode 100644
index 0000000000..0c948eefec
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_fork_env.rs
@@ -0,0 +1,79 @@
+use crate::{WasiEnv, WasiError, WasiVFork};
+use wasmer::{FunctionEnvMut, Memory, MemorySize, WasmPtr};
+use wasmer_wasix_types::wasi::{Errno, Pid};
+
+/// ### `proc_fork_env()`
+/// Forks the environment of the current process into a new child process.
+/// The child process will start with the same memory and execution context
+/// as the parent process, similar to `fork()`.
+///
+/// Most syscalls are undefined behavior in the child process, except for
+/// `proc_exit2()` and `proc_exec3()`. `proc_exit2()` will terminate the
+/// child process and set the environment back to the parent process.
+/// `proc_exec3()` will exec the module in the child process and promote
+/// the child process to a real process. Then it will return with the
+/// environment back to the parent process.
+///
+/// This function differs from a traditional `vfork` in that it does not
+/// modify the control flow of the program. Instead, it only forks the
+/// WasiEnv, but leaves everything else (memory, call stack, store etc.)
+/// untouched.
+///
+/// This function is intended to be used in conjunction with
+/// setjmp/longjmp to build a lightweight implementation of vforking.
+///
+/// The value at child_pid_ptr will only be modified by a successful
+/// call to this function. It will contain the process id of the
+/// child process.
+#[tracing::instrument(level = "trace", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
+pub fn proc_fork_env<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    child_pid_ptr: WasmPtr<Pid, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let env = ctx.data();
+
+    if let Some(vfork) = env.vfork.as_ref() {
+        tracing::warn!("Nested vforks are not supported");
+        return Ok(Errno::Notsup);
+    }
+
+    // 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, child_handle) = match env.fork() {
+        Ok(p) => p,
+        Err(err) => {
+            tracing::error!("Could not fork process: {err}");
+            // TODO: evaluate the appropriate error code, document it in the spec.
+            return Ok(Errno::Perm);
+        }
+    };
+
+    // Write the child's PID to the provided pointer
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem_ok!(child_pid_ptr.write(&memory, child_env.pid().raw()));
+
+    let parent_env = ctx.data_mut();
+
+    // Add the child to the parent's list of children
+    parent_env
+        .process
+        .lock()
+        .children
+        .push(child_env.process.clone());
+    // Swap the current environment with the child environment
+    child_env.swap_inner(parent_env);
+    std::mem::swap(parent_env, &mut child_env);
+
+    let previous_vfork = parent_env.vfork.replace(WasiVFork {
+        asyncify: None,
+        env: Box::new(child_env),
+        handle: child_handle,
+    });
+    assert!(previous_vfork.is_none()); // Already checked at the start of the function
+
+    Ok(Errno::Success)
+}
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..87c12ea03e 100644
--- a/lib/wasix/src/syscalls/wasix/proc_join.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_join.rs
@@ -5,7 +5,7 @@ use wasmer::FromToNativeWasmType;
 use wasmer_wasix_types::wasi::{JoinFlags, JoinStatus, JoinStatusType, JoinStatusUnion, OptionPid};
 
 use super::*;
-use crate::{syscalls::*, WasiProcess};
+use crate::{WasiProcess, syscalls::*};
 
 #[derive(Serialize, Deserialize)]
 enum JoinStatusResult {
@@ -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
@@ -93,6 +93,7 @@ pub(super) fn proc_join_internal<M: MemorySize + 'static>(
     let option_pid = match option_pid.tag {
         OptionTag::None => None,
         OptionTag::Some => Some(option_pid.pid),
+        _ => return Ok(Errno::Inval),
     };
     tracing::trace!("filter_pid = {:?}", option_pid);
 
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..ac16722e16
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
@@ -0,0 +1,34 @@
+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..884717875e 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);
     }
 
@@ -126,16 +125,16 @@ pub fn proc_spawn_internal(
     let env = ctx.data();
 
     // Preopen
-    if let Some(preopen) = preopen {
-        if !preopen.is_empty() {
-            for preopen in preopen {
-                warn!(
-                    "preopens are not yet supported for spawned processes [{}]",
-                    preopen
-                );
-            }
-            return Ok(Err(Errno::Notsup));
+    if let Some(preopen) = preopen
+        && !preopen.is_empty()
+    {
+        for preopen in preopen {
+            warn!(
+                "preopens are not yet supported for spawned processes [{}]",
+                preopen
+            );
         }
+        return Ok(Err(Errno::Notsup));
     }
 
     // Change the current directory
@@ -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..cc64b740ef
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
@@ -0,0 +1,297 @@
+use wasmer::FromToNativeWasmType;
+use wasmer_wasix_types::wasi::ProcSpawnFdOpName;
+
+use super::*;
+use crate::{
+    VIRTUAL_ROOT_FD, WasiFs,
+    os::task::{OwnedTaskStatus, TaskStatus},
+    syscalls::*,
+};
+
+/// 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
+            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)
+                && !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)
+                && !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
+                );
+            }
+
+            // According to POSIX dup2 semantics, the target fd should always be closed before duplication
+            // EXCEPT when duplicating a fd to itself (src_fd == fd), which is a no-op.
+            if op.src_fd != op.fd && 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),
+            }
+        }
+        _ => Err(Errno::Inval),
+    }
+}
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..5f7678c021
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/reflect_signature.rs
@@ -0,0 +1,134 @@
+use crate::{WasiEnv, WasiError, WasiModuleTreeHandles, state::FunctionLookupError};
+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 is_closure = WasiModuleTreeHandles::is_closure(&mut ctx, function_id).map_err(|e| {
+        trace!("Failed to check if function is a closure: {}", e);
+        WasiError::Exit(Errno::Noexec.into())
+    })?;
+    let cacheable = if is_closure { Bool::False } else { Bool::True };
+
+    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(_) => cacheable,
+                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 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..8c878af328 100644
--- a/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
@@ -9,14 +9,17 @@ 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,
     opt: Sockoption,
     ret_flag: WasmPtr<Bool, M>,
 ) -> Errno {
-    let option: crate::net::socket::WasiSocketOption = opt.into();
+    let option: crate::net::socket::WasiSocketOption = match opt.try_into() {
+        Ok(o) => o,
+        Err(_) => return Errno::Inval,
+    };
     let flag = wasi_try!(__sock_actor(
         &mut ctx,
         sock,
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..15d8321c6c 100644
--- a/lib/wasix/src/syscalls/wasix/sock_send_file.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_send_file.rs
@@ -1,7 +1,7 @@
 use virtual_fs::AsyncReadExt;
 
 use super::*;
-use crate::{net::socket::TimeType, syscalls::*, WasiInodes};
+use crate::{WasiInodes, net::socket::TimeType, syscalls::*};
 
 /// ### `sock_send_file()`
 /// Sends the entire contents of a file down a socket
@@ -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 { 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 { 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,26 +191,24 @@ 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
                                 let mut buf = vec![0u8; sub_count as usize];
 
                                 let mut buf_read = &buffer[offset..];
-                                let amt = wasi_try_ok_ok!(std::io::Read::read(
-                                    &mut buf_read,
-                                    &mut buf[..]
-                                )
-                                .map_err(map_io_err));
+                                let amt = wasi_try_ok_ok!(
+                                    std::io::Read::read(&mut buf_read, &mut buf[..])
+                                        .map_err(map_io_err)
+                                );
                                 buf.truncate(amt);
                                 buf
                             }
@@ -200,7 +217,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..f7ddbebe96 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))
         })?;
     }
 
@@ -42,7 +44,10 @@ pub(crate) fn sock_set_opt_flag_internal(
     opt: Sockoption,
     flag: bool,
 ) -> Result<Result<(), Errno>, WasiError> {
-    let option: crate::net::socket::WasiSocketOption = opt.into();
+    let option: crate::net::socket::WasiSocketOption = match opt.try_into() {
+        Ok(o) => o,
+        Err(_) => return Ok(Err(Errno::Inval)),
+    };
     wasi_try_ok_ok!(__sock_actor_mut(
         ctx,
         sock,
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..adf2359947 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))
         })?;
     }
 
@@ -45,7 +47,10 @@ pub(crate) fn sock_set_opt_size_internal(
         _ => return Ok(Err(Errno::Inval)),
     };
 
-    let option: crate::net::socket::WasiSocketOption = opt.into();
+    let option: crate::net::socket::WasiSocketOption = match opt.try_into() {
+        Ok(o) => o,
+        Err(_) => return Ok(Err(Errno::Inval)),
+    };
     wasi_try_ok_ok!(__sock_actor_mut(
         ctx,
         sock,
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..6bd98f7556 100644
--- a/lib/wasix/src/syscalls/wasix/stack_restore.rs
+++ b/lib/wasix/src/syscalls/wasix/stack_restore.rs
@@ -1,3 +1,5 @@
+use bincode::config;
+
 use super::*;
 use crate::syscalls::*;
 
@@ -14,12 +16,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 +37,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) };
@@ -43,7 +47,9 @@ pub fn stack_restore<M: MemorySize>(
             let pid = ctx.data().pid();
             let tid = ctx.data().tid();
 
-            let rewind_result = bincode::serialize(&val).unwrap().into();
+            let rewind_result = bincode::encode_to_vec(val, config::legacy())
+                .unwrap()
+                .into();
             let ret = rewind_ext::<M>(
                 &mut ctx,
                 None, // we do not restore the thread memory as `longjmp`` is not meant to do this
@@ -61,7 +67,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..aedf26c74c 100644
--- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs
@@ -4,14 +4,14 @@ use super::*;
 #[cfg(feature = "journal")]
 use crate::journal::JournalEffector;
 use crate::{
-    capture_store_snapshot,
+    WasiThreadHandle,
     os::task::thread::WasiMemoryLayout,
     runtime::{
-        task_manager::{TaskWasm, TaskWasmRunProperties},
         TaintReason,
+        task_manager::{TaskWasm, TaskWasmRunProperties},
     },
+    state::context_switching::ContextSwitchingEnvironment,
     syscalls::*,
-    WasiThreadHandle,
 };
 
 use wasmer::Memory;
@@ -30,18 +30,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 +51,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 +68,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 +79,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 +121,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 +159,129 @@ 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>(
+    ctx: &WasiFunctionEnv,
+    mut store: Store,
+    start_ptr_offset: M::Offset,
+) -> (Store, Result<(), DeepSleepWork>) {
+    // Note: we ensure both unwraps can happen before getting to this point
+    let spawn = ctx
+        .data(&store)
+        .inner()
+        .main_module_instance_handles()
+        .thread_spawn
+        .clone()
+        .unwrap();
+    let tid = ctx.data(&store).tid();
+
+    let spawn: Function = spawn.into();
+    let tid_i32 = tid.raw().try_into().map_err(|_| Errno::Overflow).unwrap();
+    let start_pointer_i32 = start_ptr_offset
+        .try_into()
+        .map_err(|_| Errno::Overflow)
+        .unwrap();
+    let (mut store, thread_result) = ContextSwitchingEnvironment::run_main_context(
+        ctx,
+        store,
+        spawn,
+        vec![Value::I32(tid_i32), Value::I32(start_pointer_i32)],
+    );
+    let thread_result = thread_result.map(|_| ());
+
+    trace!("callback finished (ret={:?})", thread_result);
+
+    let exit_code = match handle_thread_result(ctx, &mut store, thread_result) {
+        Ok(code) => code,
+        Err(deep_sleep) => return (store, Err(deep_sleep)),
+    };
+
+    // Clean up the environment on exit
+    ctx.on_exit(&mut store, exit_code);
+    (store, 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 +289,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 +304,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 (store, ret) = call_module_internal::<M>(&ctx, 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..d97accdb06 100644
--- a/lib/wasix/src/syscalls/wasix/tty_set.rs
+++ b/lib/wasix/src/syscalls/wasix/tty_set.rs
@@ -1,13 +1,15 @@
 use super::*;
-use crate::{syscalls::*, WasiTtyState};
+use crate::{WasiTtyState, syscalls::*};
 
 /// ### `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..b9017cc409 100644
--- a/lib/wasix/src/utils/mod.rs
+++ b/lib/wasix/src/utils/mod.rs
@@ -1,6 +1,7 @@
 mod dummy_waker;
 mod owned_mutex_guard;
 pub mod store;
+pub mod thread_local_executor;
 mod thread_parker;
 
 #[cfg(feature = "js")]
@@ -9,24 +10,14 @@ pub(crate) mod web;
 pub use self::{dummy_waker::WasiDummyWaker, thread_parker::WasiParkingLot};
 
 pub(crate) use owned_mutex_guard::{
-    read_owned, write_owned, OwnedRwLockReadGuard, OwnedRwLockWriteGuard,
+    OwnedRwLockReadGuard, OwnedRwLockWriteGuard, read_owned, write_owned,
 };
-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/src/utils/store.rs b/lib/wasix/src/utils/store.rs
index fdfb6ae2fb..d956dbaeb7 100644
--- a/lib/wasix/src/utils/store.rs
+++ b/lib/wasix/src/utils/store.rs
@@ -1,3 +1,5 @@
+use bincode::config;
+
 /// A snapshot that captures the runtime state of an instance.
 #[derive(Default, serde::Serialize, serde::Deserialize, Clone, Debug)]
 pub struct StoreSnapshot {
@@ -6,12 +8,12 @@ pub struct StoreSnapshot {
 }
 
 impl StoreSnapshot {
-    pub fn serialize(&self) -> Result<Vec<u8>, bincode::Error> {
-        bincode::serialize(self)
+    pub fn serialize(&self) -> Result<Vec<u8>, bincode::error::EncodeError> {
+        bincode::serde::encode_to_vec(self, config::legacy())
     }
 
-    pub fn deserialize(data: &[u8]) -> Result<Self, bincode::Error> {
-        bincode::deserialize(data)
+    pub fn deserialize(data: &[u8]) -> Result<Self, bincode::error::DecodeError> {
+        bincode::serde::decode_from_slice(data, config::legacy()).map(|(ret, _)| ret)
     }
 }
 
diff --git a/lib/wasix/src/utils/thread_local_executor.rs b/lib/wasix/src/utils/thread_local_executor.rs
new file mode 100644
index 0000000000..74914f29dc
--- /dev/null
+++ b/lib/wasix/src/utils/thread_local_executor.rs
@@ -0,0 +1,96 @@
+use futures::{
+    executor::{LocalPool, LocalSpawner},
+    task::LocalSpawnExt,
+};
+use std::thread::ThreadId;
+use thiserror::Error;
+
+/// A `Send`able spawner that spawns onto a thread-local executor
+///
+/// Despite being `Send`, the spawner enforces at runtime that
+/// it is only used to spawn on the thread it was created on.
+//
+// If that limitation is a problem, we can consider implementing a version that
+// accepts `Send` futures and sends them to the correct thread via channels.
+#[derive(Clone, Debug)]
+pub(crate) struct ThreadLocalSpawner {
+    /// A reference to the local executor's spawner
+    spawner: LocalSpawner,
+    /// The thread this spawner is associated with
+    ///
+    /// Used to generate better error messages when trying to spawn on the wrong thread
+    thread: ThreadId,
+}
+// SAFETY: The ThreadLocalSpawner enforces the spawner is only used on the correct thread.
+// See the safety comment in ThreadLocalSpawner::spawn_local and ThreadLocalSpawner::spawner
+unsafe impl Send for ThreadLocalSpawner {}
+// SAFETY: The ThreadLocalSpawner enforces the spawner is only used on the correct thread.
+// See the safety comment in ThreadLocalSpawner::spawn_local and ThreadLocalSpawner::spawner
+unsafe impl Sync for ThreadLocalSpawner {}
+
+/// Errors that can occur during `spawn_local` calls
+#[derive(Debug, Error)]
+pub enum ThreadLocalSpawnerError {
+    #[error(
+        "The ThreadLocalSpawner can only spawn tasks on the thread it was created on. Expected to be on {expected:?} but was actually on {found:?}"
+    )]
+    NotOnTheCorrectThread { expected: ThreadId, found: ThreadId },
+    #[error(
+        "The local executor associated with this spawner has been shut down and cannot accept new tasks"
+    )]
+    LocalPoolShutDown,
+    #[error("An error occurred while spawning the task")]
+    SpawnError,
+}
+
+impl ThreadLocalSpawner {
+    /// Spawn a future onto the same thread as the local spawner
+    ///
+    /// Needs to be called from the same thread on which the associated executor was created
+    pub(crate) fn spawn_local<F: Future<Output = ()> + 'static>(
+        &self,
+        future: F,
+    ) -> Result<(), ThreadLocalSpawnerError> {
+        // SAFETY: This is what makes implementing Send on ThreadLocalSpawner safe. We ensure that we only spawn
+        // on the same thread as the one the spawner was created on.
+        if std::thread::current().id() != self.thread {
+            return Err(ThreadLocalSpawnerError::NotOnTheCorrectThread {
+                expected: self.thread,
+                found: std::thread::current().id(),
+            });
+        }
+
+        // As we now know that we are on the correct thread, we can use the spawner safely
+        self.spawner
+            .spawn_local(future)
+            .map_err(|e| match e.is_shutdown() {
+                true => ThreadLocalSpawnerError::LocalPoolShutDown,
+                false => ThreadLocalSpawnerError::SpawnError,
+            })
+    }
+}
+
+/// A thread-local executor that can run tasks on the current thread
+pub(crate) struct ThreadLocalExecutor {
+    /// The local pool
+    pool: LocalPool,
+}
+
+impl ThreadLocalExecutor {
+    pub(crate) fn new() -> Self {
+        let local_pool = futures::executor::LocalPool::new();
+        Self { pool: local_pool }
+    }
+
+    pub(crate) fn spawner(&self) -> ThreadLocalSpawner {
+        ThreadLocalSpawner {
+            spawner: self.pool.spawner(),
+            // SAFETY: This will always be the thread where the spawner was created on, as the ThreadLocalExecutor is not Send
+            thread: std::thread::current().id(),
+        }
+    }
+
+    pub(crate) fn run_until<F: Future>(&mut self, future: F) -> F::Output {
+        self.pool.run_until(future)
+    }
+}
diff --git a/lib/wasix/tests/.gitignore b/lib/wasix/tests/.gitignore
new file mode 100644
index 0000000000..dba9407aa1
--- /dev/null
+++ b/lib/wasix/tests/.gitignore
@@ -0,0 +1 @@
+*/*.test.wasm
\ No newline at end of file
diff --git a/lib/wasix/tests/README.md b/lib/wasix/tests/README.md
index 3453e286c2..38bb5e1442 100644
--- a/lib/wasix/tests/README.md
+++ b/lib/wasix/tests/README.md
@@ -440,7 +440,7 @@ and mapped directories to serve HTTP content.
 
 ```sh
 cd ../../cli
-cargo run --features compiler,cranelift,debug -- --enable-threads --mapdir /public:/prog/deploy/wasmer-web/public ../wasix/tests/web-server.wasm -- --port 8080 --log-level trace
+cargo run --features compiler,cranelift,debug -- --enable-threads --volume /prog/deploy/wasmer-web/public:/public ../wasix/tests/web-server.wasm -- --port 8080 --log-level trace
 ```
 
 Note: This requires that a curl command be made to the HTTP server asynchronously
diff --git a/lib/wasix/tests/context_switching.rs b/lib/wasix/tests/context_switching.rs
new file mode 100644
index 0000000000..f085cec18d
--- /dev/null
+++ b/lib/wasix/tests/context_switching.rs
@@ -0,0 +1,162 @@
+use std::path::PathBuf;
+use std::process::Command;
+use wasmer::Module;
+use wasmer_types::ModuleHash;
+use wasmer_wasix::runners::wasi::{RuntimeOrEngine, WasiRunner};
+
+fn test_with_wasixcc(name: &str) -> Result<(), anyhow::Error> {
+    eprintln!("Compiling test case: {}", name);
+    let test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join(PathBuf::from(
+            file!()
+                .split('/')
+                .next_back()
+                .unwrap()
+                .trim_end_matches(".rs"),
+        ));
+    let main_c = test_dir.join(format!("{name}.c"));
+    let main_wasm = test_dir.join(format!("{name}.test.wasm"));
+
+    // Compile with wasixcc
+    let mut command = Command::new("wasixcc");
+    command
+        .arg(&main_c)
+        .arg("-fwasm-exceptions")
+        .arg("-o")
+        .arg(&main_wasm)
+        .current_dir(&test_dir);
+    eprintln!("Running wasixcc: {:?}", command);
+    let compile_status = command.status().expect("Failed to run wasixcc");
+    assert!(compile_status.success(), "wasixcc compilation failed");
+
+    // Load the compiled WASM module
+    let wasm_bytes = std::fs::read(&main_wasm).expect("Failed to read compiled WASM file");
+    let engine = wasmer::Engine::default();
+    let module = Module::new(&engine, &wasm_bytes).expect("Failed to create module");
+
+    // Run the WASM module using WasiRunner
+    let runner = WasiRunner::new();
+    runner.run_wasm(
+        RuntimeOrEngine::Engine(engine),
+        "wasix-test",
+        module,
+        ModuleHash::random(),
+    )
+}
+
+// macOS is currently disabled, because cranelift does not
+// support exception handling on that platform yet.
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_simple_switching() {
+    test_with_wasixcc("simple_switching").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_switching_with_main() {
+    test_with_wasixcc("switching_with_main").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_switching_to_a_deleted_context() {
+    test_with_wasixcc("switching_to_a_deleted_context").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_switching_threads() {
+    test_with_wasixcc("switching_in_threads").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_multiple_contexts() {
+    test_with_wasixcc("multiple_contexts").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_error_handling() {
+    test_with_wasixcc("error_handling").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_nested_switches() {
+    test_with_wasixcc("nested_switches").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_mutexes() {
+    test_with_wasixcc("contexts_with_mutexes").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_env_vars() {
+    test_with_wasixcc("contexts_with_env_vars").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_signals() {
+    test_with_wasixcc("contexts_with_signals").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_timers() {
+    test_with_wasixcc("contexts_with_timers").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_pipes() {
+    test_with_wasixcc("contexts_with_pipes").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_pending_file_operations() {
+    test_with_wasixcc("pending_file_operations").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_recursive_host_calls() {
+    test_with_wasixcc("recursive_host_calls").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_malloc_during_switch() {
+    test_with_wasixcc("malloc_during_switch").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_nested_host_call_switch() {
+    test_with_wasixcc("nested_host_call_switch").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_switch_to_never_resumed() {
+    test_with_wasixcc("switch_to_never_resumed").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_three_way_recursion() {
+    test_with_wasixcc("three_way_recursion").unwrap();
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_contexts_with_setjmp() {
+    test_with_wasixcc("contexts_with_setjmp").unwrap();
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_env_vars.c b/lib/wasix/tests/context_switching/contexts_with_env_vars.c
new file mode 100644
index 0000000000..6176f42829
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_env_vars.c
@@ -0,0 +1,72 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wasix/context.h>
+
+// Test context switching with environment variable operations
+
+wasix_context_id_t ctx1, ctx2;
+
+void context1_fn(void) {
+  // Set an environment variable
+  int ret = setenv("CTX_TEST_VAR", "from_context_1", 1);
+  assert(ret == 0 && "Failed to set env var in context 1");
+
+  const char *val = getenv("CTX_TEST_VAR");
+  assert(val != NULL && "Env var should exist");
+  assert(strcmp(val, "from_context_1") == 0 && "Env var should match");
+
+  // Switch to context 2
+  wasix_context_switch(ctx2);
+
+  // After resuming, check if context 2 modified it
+  val = getenv("CTX_TEST_VAR");
+  assert(val != NULL && "Env var should still exist");
+  assert(strcmp(val, "from_context_2") == 0 &&
+         "Env var should be modified by context 2");
+
+  // Clean up
+  unsetenv("CTX_TEST_VAR");
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  // Check that we can see the env var set by context 1
+  const char *val = getenv("CTX_TEST_VAR");
+  assert(val != NULL && "Env var should be visible in context 2");
+  assert(strcmp(val, "from_context_1") == 0 &&
+         "Env var should have context 1's value");
+
+  // Modify it
+  int ret = setenv("CTX_TEST_VAR", "from_context_2", 1);
+  assert(ret == 0 && "Failed to modify env var in context 2");
+
+  // Switch back to context 1
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Verify env var was cleaned up
+  const char *val = getenv("CTX_TEST_VAR");
+  assert(val == NULL && "Env var should be cleaned up");
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Environment variable switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_mutexes.c b/lib/wasix/tests/context_switching/contexts_with_mutexes.c
new file mode 100644
index 0000000000..49dc5997c5
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_mutexes.c
@@ -0,0 +1,76 @@
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+// Test context switching with pthread mutexes
+
+wasix_context_id_t ctx1, ctx2;
+pthread_mutex_t shared_mutex;
+int shared_counter = 0;
+
+void context1_fn(void) {
+  // Lock mutex in context 1
+  int ret = pthread_mutex_lock(&shared_mutex);
+  assert(ret == 0 && "Failed to lock mutex in context 1");
+
+  shared_counter++;
+  assert(shared_counter == 1 && "Counter should be 1");
+
+  // Switch to context 2 while holding the mutex
+  // Context 2 should be able to unlock it (same thread, shared mutex state)
+  wasix_context_switch(ctx2);
+
+  // After resuming, verify counter was updated by context 2
+  assert(shared_counter == 2 && "Counter should be 2 after context 2");
+
+  // Lock again to verify mutex is still usable
+  ret = pthread_mutex_lock(&shared_mutex);
+  assert(ret == 0 && "Failed to lock mutex again in context 1");
+
+  pthread_mutex_unlock(&shared_mutex);
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  // Unlock the mutex that was locked by context 1
+  // This tests that mutex state is shared across contexts (same thread)
+  int ret = pthread_mutex_unlock(&shared_mutex);
+  assert(ret == 0 && "Failed to unlock mutex in context 2");
+
+  shared_counter++;
+  assert(shared_counter == 2 && "Counter should be 2");
+
+  // Switch back to context 1 without the mutex locked
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  // Initialize mutex
+  pthread_mutex_init(&shared_mutex, NULL);
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Verify final state
+  assert(shared_counter == 2 && "Final counter should be 2");
+
+  // Cleanup
+  pthread_mutex_destroy(&shared_mutex);
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Mutex switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_pipes.c b/lib/wasix/tests/context_switching/contexts_with_pipes.c
new file mode 100644
index 0000000000..c69b626959
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_pipes.c
@@ -0,0 +1,77 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+// Test context switching with pipe I/O
+
+wasix_context_id_t ctx1, ctx2;
+int pipe_fds[2];
+
+#define MSG1 "Message from context 1"
+#define MSG2 "Message from context 2"
+
+void context1_fn(void) {
+  char buffer[128];
+
+  // Write to pipe
+  ssize_t n = write(pipe_fds[1], MSG1, strlen(MSG1));
+  assert(n == strlen(MSG1) && "Failed to write to pipe");
+
+  // Switch to context 2
+  wasix_context_switch(ctx2);
+
+  // After resuming, read what context 2 wrote
+  memset(buffer, 0, sizeof(buffer));
+  n = read(pipe_fds[0], buffer, sizeof(buffer) - 1);
+  assert(n == strlen(MSG2) && "Failed to read from pipe");
+  assert(strcmp(buffer, MSG2) == 0 && "Read incorrect data");
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  char buffer[128];
+
+  // Read what context 1 wrote
+  memset(buffer, 0, sizeof(buffer));
+  ssize_t n = read(pipe_fds[0], buffer, sizeof(buffer) - 1);
+  assert(n == strlen(MSG1) && "Failed to read from pipe");
+  assert(strcmp(buffer, MSG1) == 0 && "Read incorrect data");
+
+  // Write response
+  n = write(pipe_fds[1], MSG2, strlen(MSG2));
+  assert(n == strlen(MSG2) && "Failed to write to pipe");
+
+  // Switch back to context 1
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  // Create pipe
+  ret = pipe(pipe_fds);
+  assert(ret == 0 && "Failed to create pipe");
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Cleanup
+  close(pipe_fds[0]);
+  close(pipe_fds[1]);
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Pipe I/O switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_setjmp.c b/lib/wasix/tests/context_switching/contexts_with_setjmp.c
new file mode 100644
index 0000000000..6989fa30b4
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_setjmp.c
@@ -0,0 +1,66 @@
+#include <assert.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+// Test context switching with setjmp/longjmp (which manipulates stack state)
+
+wasix_context_id_t ctx1, ctx2;
+jmp_buf jump_buffer;
+int phase = 0;
+
+void context1_fn(void) {
+  int val;
+
+  // Set up a jump point
+  val = setjmp(jump_buffer);
+
+  if (val == 0) {
+    // First time through
+    phase = 1;
+    wasix_context_switch(ctx2);
+
+    // After resuming from ctx2
+    phase = 3;
+    // Try to longjmp after context switch
+    longjmp(jump_buffer, 1);
+  } else {
+    // Jumped back here
+    phase = 4;
+    wasix_context_switch(wasix_context_main);
+  }
+}
+
+void context2_fn(void) {
+  phase = 2;
+
+  // Do some operations
+  char *buf = malloc(1024);
+  free(buf);
+
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Verify execution order
+  assert(phase == 4 && "Should have gone through all phases");
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Setjmp/longjmp switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_signals.c b/lib/wasix/tests/context_switching/contexts_with_signals.c
new file mode 100644
index 0000000000..b853ae1c73
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_signals.c
@@ -0,0 +1,69 @@
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+// Test context switching with signal handlers
+
+wasix_context_id_t ctx1, ctx2;
+volatile int signal_received = 0;
+
+void signal_handler(int sig) {
+  signal_received++;
+  fprintf(stderr, "Signal %d received (count=%d)\n", sig, signal_received);
+}
+
+void context1_fn(void) {
+  // Install signal handler
+  signal(SIGUSR1, signal_handler);
+
+  // Raise a signal
+  raise(SIGUSR1);
+  assert(signal_received == 1 && "Signal should have been received");
+
+  // Switch to context 2
+  wasix_context_switch(ctx2);
+
+  // After resuming, check if context 2's signal was received
+  assert(signal_received == 2 &&
+         "Signal from context 2 should have been received");
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  // The signal handler should still be installed
+  // (signal handlers are per-process, not per-context)
+
+  // Raise another signal
+  raise(SIGUSR1);
+  assert(signal_received == 2 && "Second signal should have been received");
+
+  // Switch back to context 1
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Verify both signals were received
+  assert(signal_received == 2 && "Total of 2 signals should be received");
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Signal handling switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/contexts_with_timers.c b/lib/wasix/tests/context_switching/contexts_with_timers.c
new file mode 100644
index 0000000000..a6f55cb48b
--- /dev/null
+++ b/lib/wasix/tests/context_switching/contexts_with_timers.c
@@ -0,0 +1,76 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+// Test context switching with time operations
+
+wasix_context_id_t ctx1, ctx2;
+
+void context1_fn(void) {
+  struct timespec start, end;
+
+  // Get time before sleep
+  clock_gettime(CLOCK_MONOTONIC, &start);
+
+  // Sleep for a short time
+  usleep(10000); // 10ms
+
+  // Get time after sleep
+  clock_gettime(CLOCK_MONOTONIC, &end);
+
+  // Calculate elapsed time
+  long elapsed_ns =
+      (end.tv_sec - start.tv_sec) * 1000000000L + (end.tv_nsec - start.tv_nsec);
+  assert(elapsed_ns >= 10000000 && "Sleep should take at least 10ms");
+
+  // Switch to context 2
+  wasix_context_switch(ctx2);
+
+  // After resuming, do another timing operation
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  usleep(5000); // 5ms
+  clock_gettime(CLOCK_MONOTONIC, &end);
+
+  elapsed_ns =
+      (end.tv_sec - start.tv_sec) * 1000000000L + (end.tv_nsec - start.tv_nsec);
+  assert(elapsed_ns >= 5000000 && "Second sleep should take at least 5ms");
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  struct timespec ts;
+
+  // Get current time
+  clock_gettime(CLOCK_REALTIME, &ts);
+  assert(ts.tv_sec > 0 && "Should have valid timestamp");
+
+  // Do a small sleep
+  usleep(3000); // 3ms
+
+  // Switch back to context 1
+  wasix_context_switch(ctx1);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Timer operations switching test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/error_handling.c b/lib/wasix/tests/context_switching/error_handling.c
new file mode 100644
index 0000000000..176fbc8e93
--- /dev/null
+++ b/lib/wasix/tests/context_switching/error_handling.c
@@ -0,0 +1,59 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+// Test error handling: invalid operations should fail with appropriate errors
+
+wasix_context_id_t ctx1;
+int test_phase = 0;
+
+void context1_fn(void) {
+  int ret;
+
+  // Test: Cannot destroy the active context (self)
+  ret = wasix_context_destroy(ctx1);
+  assert(ret == -1 && "Should fail to destroy active context");
+  assert(errno == EINVAL &&
+         "Should set errno to EINVAL for active context destroy");
+
+  test_phase = 1;
+  wasix_context_switch(wasix_context_main);
+}
+
+int main() {
+  int ret;
+
+  // Create a context
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context");
+
+  // Switch to context to test destroying active context
+  wasix_context_switch(ctx1);
+  assert(test_phase == 1 && "Context did not execute");
+
+  // Test: Cannot destroy main context
+  ret = wasix_context_destroy(wasix_context_main);
+  assert(ret == -1 && "Should fail to destroy main context");
+  assert(errno == EINVAL &&
+         "Should set errno to EINVAL for main context destroy");
+
+  // Destroy the context
+  ret = wasix_context_destroy(ctx1);
+  assert(ret == 0 && "Failed to destroy context");
+
+  // Test: Switching to a destroyed context should fail
+  errno = 0;
+  ret = wasix_context_switch(ctx1);
+  assert(ret == -1 && "Should fail to switch to destroyed context");
+  assert(errno == EINVAL && "Should set errno to EINVAL for destroyed context");
+
+  // Test: Destroying an already destroyed context is a no-op
+  ret = wasix_context_destroy(ctx1);
+  assert(ret == 0 &&
+         "Destroying already destroyed context should succeed (no-op)");
+
+  fprintf(stderr, "All error handling tests passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/malloc_during_switch.c b/lib/wasix/tests/context_switching/malloc_during_switch.c
new file mode 100644
index 0000000000..91f8848789
--- /dev/null
+++ b/lib/wasix/tests/context_switching/malloc_during_switch.c
@@ -0,0 +1,108 @@
+// Test memory allocations during context switches
+// This can trigger store context issues if malloc implementation
+// does host calls while the store is borrowed
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+void *allocations[100];
+int alloc_count = 0;
+
+void allocate_and_switch(void);
+
+void context1_fn(void) {
+  allocate_and_switch();
+
+  // Free some allocations
+  for (int i = 0; i < 10 && i < alloc_count; i++) {
+    free(allocations[i]);
+    allocations[i] = NULL;
+  }
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  allocate_and_switch();
+
+  // Reallocate some memory
+  for (int i = 10; i < 20 && i < alloc_count; i++) {
+    if (allocations[i]) {
+      allocations[i] = realloc(allocations[i], 2048);
+      assert(allocations[i] != NULL);
+    }
+  }
+
+  wasix_context_switch(ctx1);
+}
+
+void context3_fn(void) {
+  allocate_and_switch();
+
+  // More allocations
+  for (int i = 0; i < 15; i++) {
+    void *ptr = calloc(1, 512);
+    assert(ptr != NULL);
+    if (alloc_count < 100) {
+      allocations[alloc_count++] = ptr;
+    }
+  }
+
+  wasix_context_switch(ctx2);
+}
+
+void allocate_and_switch(void) {
+  // Allocate memory
+  for (int i = 0; i < 10; i++) {
+    void *ptr = malloc(1024 + i * 100);
+    assert(ptr != NULL);
+    memset(ptr, i, 1024 + i * 100);
+
+    if (alloc_count < 100) {
+      allocations[alloc_count++] = ptr;
+    }
+
+    // Switch contexts during allocations
+    if (i == 5) {
+      if (alloc_count < 30) {
+        wasix_context_switch(ctx3);
+      } else if (alloc_count < 60) {
+        wasix_context_switch(ctx2);
+      }
+    }
+  }
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  ret = wasix_context_create(&ctx3, context3_fn);
+  assert(ret == 0 && "Failed to create context 3");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Free remaining allocations
+  for (int i = 0; i < alloc_count; i++) {
+    if (allocations[i]) {
+      free(allocations[i]);
+    }
+  }
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+  wasix_context_destroy(ctx3);
+
+  fprintf(stderr, "Malloc during switch test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/multiple_contexts.c b/lib/wasix/tests/context_switching/multiple_contexts.c
new file mode 100644
index 0000000000..c2d74230ca
--- /dev/null
+++ b/lib/wasix/tests/context_switching/multiple_contexts.c
@@ -0,0 +1,74 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+// Test creating multiple contexts and switching between them in various orders
+// Expected execution order: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+int execution_order[10];
+int order_idx = 0;
+
+void context1_fn(void) {
+  execution_order[order_idx++] = 1;
+  wasix_context_switch(ctx2);
+
+  execution_order[order_idx++] = 4;
+  wasix_context_switch(ctx3);
+
+  execution_order[order_idx++] = 6;
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  execution_order[order_idx++] = 2;
+  wasix_context_switch(ctx3);
+
+  execution_order[order_idx++] = 5;
+  wasix_context_switch(ctx1);
+}
+
+void context3_fn(void) {
+  execution_order[order_idx++] = 3;
+  wasix_context_switch(ctx1);
+
+  execution_order[order_idx++] = 7;
+  wasix_context_switch(ctx2);
+}
+
+int main() {
+  int ret;
+
+  // Create three contexts
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  ret = wasix_context_create(&ctx3, context3_fn);
+  assert(ret == 0 && "Failed to create context 3");
+
+  // Start the chain by switching to context 1
+  // Expected execution order: 1 -> 2 -> 3 -> 4 -> 7 -> 5 -> 6
+  // Control flow: main -> ctx1(1) -> ctx2(2) -> ctx3(3) -> ctx1(4) -> ctx3(7)
+  // -> ctx2(5) -> ctx1(6) -> main
+  wasix_context_switch(ctx1);
+
+  // Verify execution order
+  int expected[] = {1, 2, 3, 4, 7, 5, 6};
+  assert(order_idx == 7 && "Incorrect number of context switches");
+  for (int i = 0; i < 7; i++) {
+    assert(execution_order[i] == expected[i] && "Incorrect execution order");
+  }
+
+  ret = wasix_context_destroy(ctx2);
+  assert(ret == 0 && "Failed to destroy context 2");
+
+  ret = wasix_context_destroy(ctx3);
+  assert(ret == 0 && "Failed to destroy context 3");
+
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/nested_host_call_switch.c b/lib/wasix/tests/context_switching/nested_host_call_switch.c
new file mode 100644
index 0000000000..1f63f6a107
--- /dev/null
+++ b/lib/wasix/tests/context_switching/nested_host_call_switch.c
@@ -0,0 +1,125 @@
+// Test switching contexts while nested in the middle of syscalls
+// This directly tries to trigger "store context still borrowed" by
+// calling wasix_context_switch during operations that hold a store borrow
+#include <assert.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1, ctx2;
+int phase = 0;
+
+void do_directory_operations(void);
+void do_file_operations(void);
+
+void context1_fn(void) {
+  phase = 1;
+
+  // Do syscalls that might hold store borrows
+  do_directory_operations();
+
+  phase = 3;
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  phase = 2;
+
+  // Do different syscalls while ctx1 might have pending operations
+  do_file_operations();
+
+  phase = 4;
+  wasix_context_switch(ctx1);
+}
+
+void do_directory_operations(void) {
+  // Create a directory
+  mkdir("/tmp/test_dir", 0755);
+
+  // Open the directory
+  DIR *dir = opendir("/tmp");
+  if (!dir) {
+    perror("opendir");
+    return;
+  }
+
+  // Read some entries
+  struct dirent *entry;
+  int count = 0;
+  while ((entry = readdir(dir)) != NULL && count < 5) {
+    count++;
+
+    // Switch context while directory is open and we're in the middle of reading
+    if (count == 2) {
+      wasix_context_switch(ctx2);
+      // After resuming, continue reading directory
+    }
+  }
+
+  // Close directory
+  closedir(dir);
+
+  // Remove the directory
+  rmdir("/tmp/test_dir");
+}
+
+void do_file_operations(void) {
+  // Open multiple files
+  int fd1 = open("/tmp/file1.txt", O_CREAT | O_RDWR, 0644);
+  int fd2 = open("/tmp/file2.txt", O_CREAT | O_RDWR, 0644);
+
+  if (fd1 < 0 || fd2 < 0) {
+    perror("open");
+    if (fd1 >= 0)
+      close(fd1);
+    if (fd2 >= 0)
+      close(fd2);
+    return;
+  }
+
+  // Write to both
+  const char *data = "test data\n";
+  write(fd1, data, strlen(data));
+  write(fd2, data, strlen(data));
+
+  // Get file stats while files are open
+  struct stat st;
+  fstat(fd1, &st);
+
+  // Close files
+  close(fd1);
+  close(fd2);
+
+  // Remove files
+  unlink("/tmp/file1.txt");
+  unlink("/tmp/file2.txt");
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Verify phases completed
+  assert(phase >= 2 && "Should have executed both contexts");
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+
+  fprintf(stderr, "Nested host call switch test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/nested_switches.c b/lib/wasix/tests/context_switching/nested_switches.c
new file mode 100644
index 0000000000..4c88964ffc
--- /dev/null
+++ b/lib/wasix/tests/context_switching/nested_switches.c
@@ -0,0 +1,75 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+// Test nested context switches with multiple visits to each context
+
+wasix_context_id_t ctxA, ctxB, ctxC;
+int visit_count_A = 0;
+int visit_count_B = 0;
+int visit_count_C = 0;
+
+void contextA_fn(void) {
+  visit_count_A++;
+
+  if (visit_count_A == 1) {
+    // First visit: go to B
+    wasix_context_switch(ctxB);
+    // When we resume here, go to main
+    wasix_context_switch(wasix_context_main);
+  } else {
+    // Second visit: shouldn't happen in this flow
+    exit(1);
+  }
+}
+
+void contextB_fn(void) {
+  visit_count_B++;
+
+  if (visit_count_B == 1) {
+    // First visit: go to C
+    wasix_context_switch(ctxC);
+    // When we resume here, go back to A
+    wasix_context_switch(ctxA);
+  } else {
+    // Second visit: shouldn't happen in this flow
+    exit(1);
+  }
+}
+
+void contextC_fn(void) {
+  visit_count_C++;
+
+  // Switch to B to resume it
+  wasix_context_switch(ctxB);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctxA, contextA_fn);
+  assert(ret == 0 && "Failed to create context A");
+
+  ret = wasix_context_create(&ctxB, contextB_fn);
+  assert(ret == 0 && "Failed to create context B");
+
+  ret = wasix_context_create(&ctxC, contextC_fn);
+  assert(ret == 0 && "Failed to create context C");
+
+  // Start the nested chain
+  wasix_context_switch(ctxA);
+
+  // Verify contexts were visited
+  // Flow: main -> A(1) -> B(1) -> C(1) -> B -> A -> main
+  assert(visit_count_A == 1 && "Context A visited wrong number of times");
+  assert(visit_count_B == 1 && "Context B visited wrong number of times");
+  assert(visit_count_C == 1 && "Context C visited wrong number of times");
+
+  // Cleanup
+  wasix_context_destroy(ctxA);
+  wasix_context_destroy(ctxB);
+  wasix_context_destroy(ctxC);
+
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/pending_file_operations.c b/lib/wasix/tests/context_switching/pending_file_operations.c
new file mode 100644
index 0000000000..53f35f17e5
--- /dev/null
+++ b/lib/wasix/tests/context_switching/pending_file_operations.c
@@ -0,0 +1,108 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+// Test context switching while file operations are pending
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+int pipe_fds[2];
+
+void context1_fn(void) {
+  char buffer[256];
+
+  // Open a file for writing
+  FILE *fp = fopen("/tmp/ctx_test1.txt", "w");
+  assert(fp != NULL && "Failed to open file");
+
+  // Write some data
+  fprintf(fp, "Context 1 writing data\n");
+  fflush(fp);
+
+  // Don't close the file yet, switch to another context
+  wasix_context_switch(ctx2);
+
+  // After resuming, continue with the file
+  fprintf(fp, "Context 1 continued\n");
+  fclose(fp);
+
+  // Read from pipe
+  ssize_t n = read(pipe_fds[0], buffer, sizeof(buffer));
+  assert(n > 0 && "Failed to read from pipe");
+
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  char buffer[256];
+
+  // Open another file
+  FILE *fp = fopen("/tmp/ctx_test2.txt", "w");
+  assert(fp != NULL && "Failed to open file");
+
+  fprintf(fp, "Context 2 data\n");
+
+  // Write to pipe while file is open
+  write(pipe_fds[1], "pipe data", 9);
+
+  // Switch with file still open
+  wasix_context_switch(ctx3);
+
+  // Resume and close
+  fclose(fp);
+
+  wasix_context_switch(ctx1);
+}
+
+void context3_fn(void) {
+  // Do some operations
+  FILE *fp = tmpfile();
+  assert(fp != NULL && "Failed to create temp file");
+
+  fprintf(fp, "Temp data\n");
+  rewind(fp);
+
+  char buffer[64];
+  fgets(buffer, sizeof(buffer), fp);
+
+  // Switch while temp file is open
+  wasix_context_switch(ctx2);
+
+  // This code won't execute in this flow
+  fclose(fp);
+}
+
+int main() {
+  int ret;
+
+  // Create pipe
+  ret = pipe(pipe_fds);
+  assert(ret == 0 && "Failed to create pipe");
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  ret = wasix_context_create(&ctx3, context3_fn);
+  assert(ret == 0 && "Failed to create context 3");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Cleanup
+  close(pipe_fds[0]);
+  close(pipe_fds[1]);
+  unlink("/tmp/ctx_test1.txt");
+  unlink("/tmp/ctx_test2.txt");
+
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+  wasix_context_destroy(ctx3);
+
+  fprintf(stderr, "Pending file operations test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/recursive_host_calls.c b/lib/wasix/tests/context_switching/recursive_host_calls.c
new file mode 100644
index 0000000000..c073f1b67b
--- /dev/null
+++ b/lib/wasix/tests/context_switching/recursive_host_calls.c
@@ -0,0 +1,107 @@
+// Test context switching during recursive system calls
+// This tries to trigger the store context borrow error by doing
+// complex syscalls that might borrow the store while switching
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+int recursion_depth = 0;
+int max_depth = 5;
+
+void recursive_file_operations(int depth);
+
+void context1_fn(void) {
+  recursive_file_operations(0);
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  recursive_file_operations(0);
+  wasix_context_switch(ctx3);
+  // Should not reach here
+  wasix_context_switch(wasix_context_main);
+}
+
+void context3_fn(void) {
+  recursive_file_operations(0);
+  wasix_context_switch(ctx1);
+  // Should not reach here
+  wasix_context_switch(wasix_context_main);
+}
+
+void recursive_file_operations(int depth) {
+  if (depth >= max_depth) {
+    return;
+  }
+
+  recursion_depth = depth;
+
+  // Create a file with dynamic name
+  char filename[64];
+  snprintf(filename, sizeof(filename), "/tmp/test_%d_%d.txt", (int)getpid(),
+           depth);
+
+  // Open file (syscall that borrows store)
+  int fd = open(filename, O_CREAT | O_RDWR, 0644);
+  if (fd < 0) {
+    perror("open");
+    return;
+  }
+
+  // Write some data (another syscall)
+  char data[256];
+  snprintf(data, sizeof(data), "Depth: %d, PID: %d\n", depth, (int)getpid());
+  ssize_t written = write(fd, data, strlen(data));
+
+  // Switch context while file is open
+  if (depth == 2) {
+    if (recursion_depth == 2) {
+      wasix_context_switch(ctx2);
+      // After resuming, continue operations
+    }
+  }
+
+  // Recurse deeper
+  recursive_file_operations(depth + 1);
+
+  // More operations after recursion
+  lseek(fd, 0, SEEK_SET);
+  char readbuf[256] = {0};
+  read(fd, readbuf, sizeof(readbuf) - 1);
+
+  // Close the file
+  close(fd);
+
+  // Remove the file (another syscall)
+  unlink(filename);
+}
+
+int main() {
+  int ret;
+
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+
+  ret = wasix_context_create(&ctx3, context3_fn);
+  assert(ret == 0 && "Failed to create context 3");
+
+  // Start execution
+  wasix_context_switch(ctx1);
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+  wasix_context_destroy(ctx3);
+
+  fprintf(stderr, "Recursive host calls test passed\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/simple_switching.c b/lib/wasix/tests/context_switching/simple_switching.c
new file mode 100644
index 0000000000..1aefb122b0
--- /dev/null
+++ b/lib/wasix/tests/context_switching/simple_switching.c
@@ -0,0 +1,54 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+wasix_context_id_t context1;
+wasix_context_id_t context2;
+
+char *message = "Uninitialized\n";
+int stop = 0;
+int counter = 0;
+
+void test1(void) {
+  while (1) {
+    wasix_context_switch(context2);
+    if (stop == 1) {
+      wasix_context_switch(wasix_context_main);
+    }
+    counter++;
+    printf("%s", message);
+  }
+}
+
+void test2(void) {
+  printf("Starting test2\n");
+
+  message = "Switch 1\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 2\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 3\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 4\n";
+  wasix_context_switch(context1);
+
+  stop = 1;
+  wasix_context_switch(context1);
+
+  exit(1);
+}
+
+int main() {
+  wasix_context_create(&context1, test1);
+  wasix_context_create(&context2, test2);
+  wasix_context_switch(context1);
+
+  assert(counter == 4);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/lib/wasix/tests/context_switching/switch_to_never_resumed.c b/lib/wasix/tests/context_switching/switch_to_never_resumed.c
new file mode 100644
index 0000000000..b56c0baad9
--- /dev/null
+++ b/lib/wasix/tests/context_switching/switch_to_never_resumed.c
@@ -0,0 +1,116 @@
+// Test that switching to a never-resumed context activates the correct context
+// This test creates 3 contexts and switches between them to verify
+// that the correct entrypoint is called for each
+#include <assert.h>
+#include <stdio.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+int execution_order[10];
+int order_idx = 0;
+
+void context1_fn(void) {
+  fprintf(stderr, "context1_fn executing (ctx1=%llu)\n",
+          (unsigned long long)ctx1);
+  fflush(stderr);
+  execution_order[order_idx++] = 1;
+
+  // Switch to ctx2 (which has never been resumed before)
+  fprintf(stderr, "ctx1 switching to ctx2 (id=%llu)\n",
+          (unsigned long long)ctx2);
+  fflush(stderr);
+  wasix_context_switch(ctx2);
+
+  // After ctx2 switches back to us
+  fprintf(stderr, "ctx1 resumed\n");
+  fflush(stderr);
+  execution_order[order_idx++] = 4;
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  fprintf(stderr, "context2_fn executing (ctx2=%llu)\n",
+          (unsigned long long)ctx2);
+  fflush(stderr);
+  execution_order[order_idx++] = 2;
+
+  // Switch to ctx3 (which has never been resumed before)
+  fprintf(stderr, "ctx2 switching to ctx3 (id=%llu)\n",
+          (unsigned long long)ctx3);
+  fflush(stderr);
+  wasix_context_switch(ctx3);
+
+  // Should not reach here in this test
+  fprintf(stderr, "ERROR: ctx2 resumed unexpectedly\n");
+  fflush(stderr);
+  execution_order[order_idx++] = 99;
+  wasix_context_switch(wasix_context_main);
+}
+
+void context3_fn(void) {
+  fprintf(stderr, "context3_fn executing (ctx3=%llu)\n",
+          (unsigned long long)ctx3);
+  fflush(stderr);
+  execution_order[order_idx++] = 3;
+
+  // Switch back to ctx1
+  fprintf(stderr, "ctx3 switching to ctx1 (id=%llu)\n",
+          (unsigned long long)ctx1);
+  fflush(stderr);
+  wasix_context_switch(ctx1);
+
+  // Should not reach here in this test
+  fprintf(stderr, "ERROR: ctx3 resumed unexpectedly\n");
+  fflush(stderr);
+  execution_order[order_idx++] = 99;
+  wasix_context_switch(wasix_context_main);
+}
+
+int main() {
+  int ret;
+
+  // Create all three contexts while in main
+  ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+  fprintf(stderr, "Created ctx1 with id=%llu\n", (unsigned long long)ctx1);
+  fflush(stderr);
+
+  ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+  fprintf(stderr, "Created ctx2 with id=%llu\n", (unsigned long long)ctx2);
+  fflush(stderr);
+
+  ret = wasix_context_create(&ctx3, context3_fn);
+  assert(ret == 0 && "Failed to create context 3");
+  fprintf(stderr, "Created ctx3 with id=%llu\n", (unsigned long long)ctx3);
+  fflush(stderr);
+
+  // Now switch to ctx1 (which will switch to ctx2, which will switch to ctx3,
+  // which will switch back to ctx1)
+  fprintf(stderr, "Main switching to ctx1\n");
+  fflush(stderr);
+  wasix_context_switch(ctx1);
+
+  // Verify execution order: ctx1 -> ctx2 -> ctx3 -> ctx1 (resumed)
+  fprintf(stderr, "Back in main. Execution order:");
+  for (int i = 0; i < order_idx; i++) {
+    fprintf(stderr, " %d", execution_order[i]);
+  }
+  fprintf(stderr, "\n");
+  fflush(stderr);
+
+  assert(order_idx == 4 && "Should have 4 execution steps");
+  assert(execution_order[0] == 1 && "ctx1 should run first");
+  assert(execution_order[1] == 2 &&
+         "ctx2 should run second (BUG: might be ctx3)");
+  assert(execution_order[2] == 3 && "ctx3 should run third");
+  assert(execution_order[3] == 4 && "ctx1 should resume fourth");
+
+  // Cleanup
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+  wasix_context_destroy(ctx3);
+
+  fprintf(stderr, "Test passed - correct contexts were activated!\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/context_switching/switching_in_threads.c b/lib/wasix/tests/context_switching/switching_in_threads.c
new file mode 100644
index 0000000000..6f30531152
--- /dev/null
+++ b/lib/wasix/tests/context_switching/switching_in_threads.c
@@ -0,0 +1,70 @@
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+wasix_context_id_t context1;
+wasix_context_id_t context2;
+
+char *message = "Uninitialized\n";
+int stop = 0;
+int counter = 0;
+
+void test1(void) {
+  while (1) {
+    wasix_context_switch(context2);
+    if (stop == 1) {
+      wasix_context_switch(wasix_context_main);
+    }
+    counter++;
+    printf("%s", message);
+  }
+}
+
+void test2(void) {
+  printf("Starting test2\n");
+
+  message = "Switch 1\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 2\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 3\n";
+  wasix_context_switch(context1);
+
+  message = "Switch 4\n";
+  wasix_context_switch(context1);
+
+  stop = 1;
+  wasix_context_switch(context1);
+
+  exit(50);
+}
+
+void *abort_in_thread(void *arg) {
+  wasix_context_create(&context1, test1);
+  wasix_context_create(&context2, test2);
+  wasix_context_switch(context1);
+
+  return NULL;
+}
+
+int main() {
+  pthread_t thread;
+  pthread_create(&thread, NULL, abort_in_thread, NULL);
+  pthread_join(thread, NULL);
+
+  if (counter != 4) {
+    printf("Error: expected counter to be 4 but it is %d\n", counter);
+    exit(1);
+  }
+
+  return 0;
+}
\ No newline at end of file
diff --git a/lib/wasix/tests/context_switching/switching_to_a_deleted_context.c b/lib/wasix/tests/context_switching/switching_to_a_deleted_context.c
new file mode 100644
index 0000000000..674e69c1b3
--- /dev/null
+++ b/lib/wasix/tests/context_switching/switching_to_a_deleted_context.c
@@ -0,0 +1,47 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+wasix_context_id_t context1;
+wasix_context_id_t context2;
+
+int counter = 0;
+
+void test1(void) {
+  counter += 1;
+  wasix_context_switch(wasix_context_main);
+}
+
+// Required because switching with the real main currently segfaults
+void test_main(void) {
+  wasix_context_create(&context1, test1);
+  wasix_context_create(&context2, test1);
+
+  // Assert that test1 increments the context.
+  assert(counter == 0);
+  wasix_context_switch(context1);
+  assert(counter == 1);
+
+  // Assert that calling the destroyed context again fails
+  wasix_context_destroy(context1);
+  wasix_context_switch(context1);
+  assert(counter == 1);
+
+  // Assert that switching to a context that was destroyed before the first
+  // switch works
+  wasix_context_destroy(context2);
+  wasix_context_switch(context2);
+  assert(counter == 1);
+
+  exit(0);
+}
+
+int main() {
+  wasix_context_id_t test_main_context;
+  wasix_context_create(&test_main_context, test_main);
+  wasix_context_switch(test_main_context);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/lib/wasix/tests/context_switching/switching_with_main.c b/lib/wasix/tests/context_switching/switching_with_main.c
new file mode 100644
index 0000000000..96fecbd725
--- /dev/null
+++ b/lib/wasix/tests/context_switching/switching_with_main.c
@@ -0,0 +1,37 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasix/context.h>
+
+wasix_context_id_t context1;
+wasix_context_id_t context2;
+
+int stop = 0;
+int counter = 0;
+
+void test1(void) {
+  while (1) {
+    wasix_context_switch(wasix_context_main);
+    if (stop == 1) {
+      wasix_context_switch(wasix_context_main);
+      break;
+    }
+    counter++;
+  }
+}
+
+int main() {
+  wasix_context_create(&context1, test1);
+  wasix_context_switch(context1);
+
+  wasix_context_switch(context1);
+  wasix_context_switch(context1);
+  wasix_context_switch(context1);
+  wasix_context_switch(context1);
+  stop = 1;
+  wasix_context_switch(context1);
+
+  assert(counter == 4);
+  return 0;
+}
\ No newline at end of file
diff --git a/lib/wasix/tests/context_switching/three_way_recursion.c b/lib/wasix/tests/context_switching/three_way_recursion.c
new file mode 100644
index 0000000000..8cf27760be
--- /dev/null
+++ b/lib/wasix/tests/context_switching/three_way_recursion.c
@@ -0,0 +1,88 @@
+// Minimal: 3 mutually recursive funcs, 3 contexts, circular pattern
+#include <assert.h>
+#include <stdio.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1, ctx2, ctx3;
+
+void func_b(int d);
+void func_c(int d);
+
+void func_a(int d) {
+  fprintf(stderr, "[func_a] d=%d\n", d);
+  fflush(stderr);
+  if (d == 0) {
+    fprintf(stderr, "[func_a] SWITCH to ctx2\n");
+    fflush(stderr);
+    wasix_context_switch(ctx2);
+    return;
+  }
+  func_b(d - 1);
+}
+
+void func_b(int d) {
+  fprintf(stderr, "[func_b] d=%d\n", d);
+  fflush(stderr);
+  if (d == 0) {
+    fprintf(stderr, "[func_b] SWITCH to ctx3\n");
+    fflush(stderr);
+    wasix_context_switch(ctx3);
+    return;
+  }
+  func_c(d - 1);
+}
+
+void func_c(int d) {
+  fprintf(stderr, "[func_c] d=%d\n", d);
+  fflush(stderr);
+  if (d == 0) {
+    fprintf(stderr, "[func_c] SWITCH to ctx1\n");
+    fflush(stderr);
+    wasix_context_switch(ctx1);
+    return;
+  }
+  func_a(d - 1);
+}
+
+void context1_fn(void) {
+  fprintf(stderr, "ctx1_start\n");
+  fflush(stderr);
+  func_a(5);
+  fprintf(stderr, "ctx1_end\n");
+  fflush(stderr);
+  wasix_context_switch(wasix_context_main);
+}
+
+void context2_fn(void) {
+  fprintf(stderr, "ctx2_start\n");
+  fflush(stderr);
+  func_b(3);
+  fprintf(stderr, "ctx2_end\n");
+  fflush(stderr);
+  wasix_context_switch(wasix_context_main);
+}
+
+void context3_fn(void) {
+  fprintf(stderr, "ctx3_start\n");
+  fflush(stderr);
+  func_c(2);
+  fprintf(stderr, "ctx3_end\n");
+  fflush(stderr);
+  wasix_context_switch(wasix_context_main);
+}
+
+int main() {
+  wasix_context_create(&ctx1, context1_fn);
+  wasix_context_create(&ctx2, context2_fn);
+  wasix_context_create(&ctx3, context3_fn);
+
+  fprintf(stderr, "==> ctx1\n");
+  fflush(stderr);
+  wasix_context_switch(ctx1);
+
+  wasix_context_destroy(ctx1);
+  wasix_context_destroy(ctx2);
+  wasix_context_destroy(ctx3);
+  fprintf(stderr, "PASS\n");
+  return 0;
+}
diff --git a/lib/wasix/tests/envvar.rs b/lib/wasix/tests/envvar.rs
index a76f23115b..f65427e55a 100644
--- a/lib/wasix/tests/envvar.rs
+++ b/lib/wasix/tests/envvar.rs
@@ -10,17 +10,19 @@ 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");
+    unsafe {
+        env::set_var("WASI_ENVVAR_TEST", "HELLO");
+    }
 
     println!("DOG {:?}", get_env_var("DOG"));
     println!("DOG_TYPE {:?}", get_env_var("DOG_TYPE"));
diff --git a/lib/wasix/tests/runners.rs b/lib/wasix/tests/runners.rs
index b58c41e599..1fee97966a 100644
--- a/lib/wasix/tests/runners.rs
+++ b/lib/wasix/tests/runners.rs
@@ -2,37 +2,50 @@
 // 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},
+    PluggableRuntime, Runtime,
+    http::HttpClient,
     runners::Runner,
     runtime::{
         module_cache::{FileSystemCache, ModuleCache, SharedCache},
         package_loader::BuiltinPackageLoader,
         task_manager::tokio::TokioTaskManager,
     },
-    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::{
+        WasiError,
+        bin_factory::BinaryPackage,
+        runners::wasi::{RuntimeOrEngine, WasiRunner},
+    };
 
     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);
     }
@@ -100,9 +144,10 @@ mod wasi {
 mod wcgi {
     use std::{future::Future, sync::Arc};
 
-    use futures::{channel::mpsc::Sender, future::AbortHandle, SinkExt, StreamExt};
+    use futures::{SinkExt, StreamExt, channel::mpsc::Sender, future::AbortHandle};
     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..5da35297a1 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::block_on;
+use wasmer::Module;
+use wasmer_types::ModuleHash;
+use wasmer_wasix::{
+    Pipe,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+};
 
 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();
+    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,64 @@ 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();
+    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");
+    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();
+    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..0573181b96 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.74
+1.91
diff --git a/scripts/RELEASE.md b/scripts/RELEASE.md
new file mode 100644
index 0000000000..980a221388
--- /dev/null
+++ b/scripts/RELEASE.md
@@ -0,0 +1,55 @@
+# 🔧 Wasmer Release Guide
+
+## 1. Prepare the Branch
+
+Check out `main` and ensure you're on the latest commit
+
+```bash
+git checkout main
+git pull
+```
+
+## 2. Generate the Release PR
+
+Run the release script (adjust the version as needed):
+
+```bash
+python3 ./scripts/make-release.py v6.1.0
+```
+
+Wait for the script to open a PR and note the PR branch name.
+
+## 3. Edit the Changelog
+
+ Check out the PR branch:
+
+```bash
+git checkout <release-branch>
+```
+
+Update the auto-generated `CHANGELOG.md`:
+
+- Verify the commits listed
+- Add a proper summary of what's new
+
+Commit and push your changes.
+
+## 4. Merge the Release PR
+
+Wait for CI to pass and merge the PR into `main`.
+The `make-release.py` script automatically monitors the PR and both tags the release and properly publishes artifacts. Plus, a new **draft release** is created as well.
+
+## 5. Publish the Release
+
+Open the draft release, add a meaningful description (often the CHANGELOG summary), and publish it.
+
+## 6. Publish Crates
+
+Locally, check out the release tag and publish the crates:
+
+```bash
+git checkout v6.1.0
+python3 ./scripts/publish.py publish
+```
+
+🎉 **Release complete!**
diff --git a/scripts/alpine-linux-install-deps.sh b/scripts/alpine-linux-install-deps.sh
index baa2d63386..f228130ffb 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 make curl cmake ninja clang21 zstd-static llvm21-dev clang21-static llvm21-static ncurses-static zlib-static tar libxml2-static
+ln -s /usr/bin/llvm-config-21 /usr/bin/llvm-config
diff --git a/scripts/make-release.py b/scripts/make-release.py
index 7d7c9cb511..d43b3ef396 100644
--- a/scripts/make-release.py
+++ b/scripts/make-release.py
@@ -1,7 +1,7 @@
 #! /usr/bin/env python3
 
+from itertools import takewhile
 import os
-import signal
 import time
 import sys
 import subprocess
@@ -9,7 +9,7 @@
 import datetime
 import re
 
-RELEASE_VERSION=""
+RELEASE_VERSION = ""
 DATE = datetime.date.today().strftime("%d/%m/%Y")
 SIGNOFF_REVIEWER = "Arshia001"
 TAG = "main"
@@ -26,7 +26,7 @@
 
 RELEASE_VERSION_WITH_V = RELEASE_VERSION
 
-if not(RELEASE_VERSION.startswith("v")):
+if not (RELEASE_VERSION.startswith("v")):
     RELEASE_VERSION_WITH_V = "v" + RELEASE_VERSION
 else:
     RELEASE_VERSION = RELEASE_VERSION[1:]
@@ -39,65 +39,95 @@
     print("gh not installed")
     sys.exit(1)
 
+
 def get_file_string(file):
-    file_handle = open(file, 'r', newline='')
+    file_handle = open(file, "r", newline="")
     file_string = file_handle.read()
     file_handle.close()
     return file_string
 
+
 def write_file_string(file, file_string):
-    file_handle = open(file, 'w')
+    file_handle = open(file, "w")
     file_handle.write(file_string)
     file_handle.close()
 
+
 def replace(file, pattern, subst):
     file_string = get_file_string(file)
-    file_string = file_string.replace(pattern, subst,1)
+    file_string = file_string.replace(pattern, subst, 1)
     write_file_string(file, file_string)
 
+
 def make_release(version):
     gh_logged_in = os.system("gh auth status") == 0
-    if not(gh_logged_in):
+    if not (gh_logged_in):
         raise Exception("please log in")
-    
-    import tempfile
 
-    temp_dir = tempfile.TemporaryDirectory()
+    temp_dir = tempfile.TemporaryDirectory(prefix="wasmer-git-")
     print(temp_dir.name)
-    if os.system("git clone https://github.com/wasmerio/wasmer --branch " + TAG + " --depth 1 " + temp_dir.name) != 0:
+    if (
+        os.system(
+            "git clone git@github.com:wasmerio/wasmer.git --branch "
+            + TAG
+            + " --depth 1 "
+            + temp_dir.name
+        )
+        != 0
+    ):
         raise Exception("could not clone github repo")
 
-    # generate changelog
-    proc = subprocess.Popen(['gh', "search", "prs", "--repo", "wasmerio/wasmer", "--merged", "--limit", "100", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
-    proc.wait()
-    if proc.returncode != 0:
-        print(proc.stdout)
-        raise Exception("could not run gh search prs")
+    # As of now, GH CLI cannot list more items!
+    GH_LISTING_LIMIT = 1000
 
-    lines = []
-    for line in proc.stdout:
-        line = line.decode("utf-8").rstrip()
-        if "Release" in line:
-            break
-        lines.append(line)
+    # generate changelog
+    listed_prs = subprocess.check_output(
+        [
+            "gh",
+            "search",
+            "prs",
+            "--repo",
+            "wasmerio/wasmer",
+            "--merged",
+            "--limit",
+            str(GH_LISTING_LIMIT),
+            "--sort",
+            "updated",
+        ],
+        encoding="utf-8",
+        cwd=temp_dir.name,
+    ).splitlines()
+
+    listed_prs = list(takewhile(lambda line: "Release " not in line, listed_prs))
+    print(f"Listed {len(listed_prs)} merged PRs since the latest release")
+
+    # Make sure we listed all the merged PRs since the last release!
+    assert len(listed_prs) < GH_LISTING_LIMIT
 
     changed = []
     added = []
     fixed = []
     release_notes_changed = []
 
-    for l in lines:
-        fields = l.split("\t")
+    for line in listed_prs:
+        fields = line.split("\t")
         pr_number = fields[1]
         pr_text = fields[3]
-        l = "  - [#" + pr_number + "](https://github.com/wasmerio/wasmer/pull/" + pr_number + ") " + pr_text
-        release_notes_changed.append(l)
-        if "add" in l.lower():
-            added.append(l)
-        elif "fix" in l.lower():
-            fixed.append(l)
+        line = (
+            "  - [#"
+            + pr_number
+            + "](https://github.com/wasmerio/wasmer/pull/"
+            + pr_number
+            + ") "
+            + pr_text
+        )
+        release_notes_changed.append(line)
+        if "add" in line.lower():
+            added.append(line)
+        elif "fix" in line.lower():
+            fixed.append(line)
         else:
-            changed.append(l)
+            changed.append(line)
 
     changelog = []
 
@@ -122,10 +152,23 @@ def make_release(version):
     changelog.append("")
     changelog.append("")
 
-    for l in changelog:
-        print("        " + l)
-
-    proc = subprocess.Popen(['gh','search', "prs", "--repo", "wasmerio/wasmer", "--merged", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    for line in changelog:
+        print("        " + line)
+
+    proc = subprocess.Popen(
+        [
+            "gh",
+            "search",
+            "prs",
+            "--repo",
+            "wasmerio/wasmer",
+            "--merged",
+            "--sort",
+            "updated",
+        ],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
     already_released_str = ""
@@ -134,10 +177,14 @@ def make_release(version):
         if RELEASE_VERSION + "\t" in line:
             already_released_str = line
             break
-    
+
     already_released = already_released_str != ""
 
-    proc = subprocess.Popen(['gh','pr', "list", "--repo", "wasmerio/wasmer"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["gh", "pr", "list", "--repo", "wasmerio/wasmer"],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
     github_link_line = ""
@@ -146,38 +193,61 @@ def make_release(version):
         if "release-" + RELEASE_VERSION + "\t" in line:
             github_link_line = line
             break
-    
+
     print("github link line" + github_link_line)
 
     if github_link_line != "":
-        proc = subprocess.Popen(['git','pull', "origin", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "pull", "origin", "release-" + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
-        proc = subprocess.Popen(['git','checkout', "-b", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "checkout", "-b", "release-" + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
-        
-        proc = subprocess.Popen(['git','pull', "origin", "release-" + RELEASE_VERSION, "--depth", "1"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+
+        proc = subprocess.Popen(
+            ["git", "pull", "origin", "release-" + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
-        proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "log", "--oneline"], stdout=subprocess.PIPE, cwd=temp_dir.name
+        )
         proc.wait()
         for line in proc.stdout:
             print(line.rstrip())
 
-    if github_link_line == "" and not(already_released):
-
+    if github_link_line == "" and not (already_released):
         # git checkout -b release-3.0.0-rc.2
-        proc = subprocess.Popen(['git','checkout', "-b", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "checkout", "-b", "release-" + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
-        
+
         if proc.returncode != 0:
             for line in proc.stdout:
                 print(line.rstrip())
             raise Exception("could not run git checkout -b release-" + RELEASE_VERSION)
 
-        replace(temp_dir.name + "/CHANGELOG.md", "## **Unreleased**", "\r\n".join(changelog))
+        replace(
+            temp_dir.name + "/CHANGELOG.md", "## **Unreleased**", "\r\n".join(changelog)
+        )
 
-        proc = subprocess.Popen(['git','commit', "-am", "Update CHANGELOG"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "commit", "-am", "Update CHANGELOG"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
         if proc.returncode != 0:
             for line in proc.stdout:
@@ -185,37 +255,84 @@ def make_release(version):
             raise Exception("could not commit CHANGELOG " + RELEASE_VERSION_WITH_V)
 
         # Update version numbers
-        update_version_py = get_file_string(temp_dir.name + "/scripts/update-version.py")
-        previous_version = re.search("NEXT_VERSION=\'(.*)\'", update_version_py).groups(1)[0]
+        update_version_py = get_file_string(
+            temp_dir.name + "/scripts/update-version.py"
+        )
+        previous_version = re.search('NEXT_VERSION = "(.*)"', update_version_py).groups(
+            1
+        )[0]
         next_version = RELEASE_VERSION
         print("updating version " + previous_version + " -> " + next_version)
-        update_version_py = re.sub("PREVIOUS_VERSION=\'.*\'","PREVIOUS_VERSION='" + previous_version + "'", update_version_py)
-        update_version_py = re.sub("NEXT_VERSION=\'.*\'","NEXT_VERSION='" + next_version + "'", update_version_py)
-        write_file_string(temp_dir.name + "/scripts/update-version.py", update_version_py)
-        proc = subprocess.Popen(['python3', temp_dir.name + "/scripts/update-version.py"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        update_version_py = re.sub(
+            'PREVIOUS_VERSION = ".*"',
+            f'PREVIOUS_VERSION = "{previous_version}"',
+            update_version_py,
+        )
+        update_version_py = re.sub(
+            'NEXT_VERSION = ".*"',
+            f'NEXT_VERSION = "{next_version}"',
+            update_version_py,
+        )
+        write_file_string(
+            temp_dir.name + "/scripts/update-version.py", update_version_py
+        )
+        proc = subprocess.Popen(
+            ["python3", temp_dir.name + "/scripts/update-version.py"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
-        proc = subprocess.Popen(['git','commit', "-am", "Release " + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "commit", "-am", "Release " + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
         if proc.returncode != 0:
             for line in proc.stdout:
                 print(line.rstrip())
             raise Exception("could not commit CHANGELOG " + RELEASE_VERSION_WITH_V)
 
-
-        proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "log", "--oneline"], stdout=subprocess.PIPE, cwd=temp_dir.name
+        )
         for line in proc.stdout:
             line = line.decode("utf-8").rstrip()
             print(line)
         proc.wait()
 
-        proc = subprocess.Popen(['git','push', "-f", "-u", "origin", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "push", "-f", "-u", "origin", "release-" + RELEASE_VERSION],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
-        proc = subprocess.Popen(['gh','pr', "create", "--head", "release-" + RELEASE_VERSION, "--title", "Release " + RELEASE_VERSION, "--body", "[bot] Release wasmer version " + RELEASE_VERSION, "--reviewer", SIGNOFF_REVIEWER], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            [
+                "gh",
+                "pr",
+                "create",
+                "--head",
+                "release-" + RELEASE_VERSION,
+                "--title",
+                "Release " + RELEASE_VERSION,
+                "--body",
+                "[bot] Release wasmer version " + RELEASE_VERSION,
+                "--reviewer",
+                SIGNOFF_REVIEWER,
+            ],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
-        proc = subprocess.Popen(['gh','pr', "list", "--repo", "wasmerio/wasmer"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["gh", "pr", "list", "--repo", "wasmerio/wasmer"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
         for line in proc.stdout:
@@ -225,22 +342,29 @@ def make_release(version):
                 break
 
     pr_number = ""
-    if (already_released):
+    if already_released:
         pr_number = already_released_str.split("\t")[1]
         print("already released in PR " + pr_number)
     else:
         pr_number = github_link_line.split("\t")[0]
         print("releasing in PR " + pr_number)
 
-    while not(already_released):
-        proc = subprocess.Popen(['gh','pr', "checks", pr_number], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    while not (already_released):
+        proc = subprocess.Popen(
+            ["gh", "pr", "checks", pr_number], stdout=subprocess.PIPE, cwd=temp_dir.name
+        )
         proc.wait()
 
         all_checks_have_passed = True
 
-        print("Waiting for checks to pass... PR " + pr_number + "    https://github.com/wasmerio/wasmer/pull/" + pr_number)
+        print(
+            "Waiting for checks to pass... PR "
+            + pr_number
+            + "    https://github.com/wasmerio/wasmer/pull/"
+            + pr_number
+        )
         print("")
-        
+
         for line in proc.stdout:
             line = line.decode("utf-8").rstrip()
             print("    " + line)
@@ -257,7 +381,7 @@ def make_release(version):
             time.sleep(5)
 
     last_commit = ""
-    proc = subprocess.Popen(['git','log'], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(["git", "log"], stdout=subprocess.PIPE, cwd=temp_dir.name)
     proc.wait()
     if proc.returncode == 0:
         for line in proc.stdout:
@@ -271,29 +395,51 @@ def make_release(version):
     if last_commit == "":
         raise Exception("could not get last info")
 
-    proc = subprocess.Popen(['git','checkout', 'main'], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "checkout", "main"], stdout=subprocess.PIPE, cwd=temp_dir.name
+    )
     proc.wait()
     if proc.returncode != 0:
         for line in proc.stdout:
             print(line.rstrip())
         raise Exception("could not commit checkout main " + RELEASE_VERSION_WITH_V)
 
-    if not(already_released):
-        proc = subprocess.Popen(['gh','pr', "merge", "--auto", pr_number, "--merge", "--delete-branch"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    if not (already_released):
+        proc = subprocess.Popen(
+            ["gh", "pr", "merge", "--auto", pr_number, "--merge", "--delete-branch"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
     # wait for bors to merge PR
-    while not(already_released):
-
+    while not (already_released):
         print("git pull origin main...")
-        proc = subprocess.Popen(['git','pull', "origin", "main", "--depth", "1"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "pull", "origin", "main"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
         if proc.returncode != 0:
             for line in proc.stdout:
                 print(line.rstrip())
             raise Exception("could not pull origin ")
-        
-        proc = subprocess.Popen(['gh','search', "prs", "--repo", "wasmerio/wasmer", "--merged", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+
+        proc = subprocess.Popen(
+            [
+                "gh",
+                "search",
+                "prs",
+                "--repo",
+                "wasmerio/wasmer",
+                "--merged",
+                "--sort",
+                "updated",
+            ],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
 
         github_link_line = ""
@@ -302,9 +448,11 @@ def make_release(version):
             if RELEASE_VERSION + "\t" in line:
                 github_link_line = line
                 break
-                    
+
         current_commit = ""
-        proc = subprocess.Popen(['git','log'], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["git", "log"], stdout=subprocess.PIPE, cwd=temp_dir.name
+        )
         proc.wait()
         if proc.returncode == 0:
             for line in proc.stdout:
@@ -312,7 +460,7 @@ def make_release(version):
                 print(line.rstrip())
                 current_commit = line
                 break
-        else: 
+        else:
             raise Exception("could not git log main")
 
         if current_commit == "":
@@ -327,7 +475,9 @@ def make_release(version):
 
     # Select the correct merge commit to tag
     correct_checkout = ""
-    proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "log", "--oneline"], stdout=subprocess.PIPE, cwd=temp_dir.name
+    )
     proc.wait()
     if proc.returncode == 0:
         for line in proc.stdout:
@@ -344,29 +494,62 @@ def make_release(version):
     checkout_hash = correct_checkout.split(" ")[0]
     print("checking out hash " + checkout_hash)
 
-    proc = subprocess.Popen(['git','tag', "-d", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "tag", "-d", RELEASE_VERSION_WITH_V],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
-    proc = subprocess.Popen(['git','push', "-d", "origin", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "push", "-d", "origin", RELEASE_VERSION_WITH_V],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
-    proc = subprocess.Popen(['git','tag', RELEASE_VERSION_WITH_V, checkout_hash], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "tag", RELEASE_VERSION_WITH_V, checkout_hash],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
-    proc = subprocess.Popen(['git','push', "-f", "origin", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc = subprocess.Popen(
+        ["git", "push", "-f", "origin", RELEASE_VERSION_WITH_V],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
     # Make release and wait for it to finish
-    if not(already_released):
-        proc = subprocess.Popen(['gh','workflow', "run", "build.yml", "--field", "release=" + RELEASE_VERSION_WITH_V, "--ref", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    if not (already_released):
+        proc = subprocess.Popen(
+            [
+                "gh",
+                "workflow",
+                "run",
+                "build.yml",
+                "--field",
+                "release=" + RELEASE_VERSION_WITH_V,
+                "--ref",
+                RELEASE_VERSION_WITH_V,
+            ],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
         time.sleep(5)
 
     while True:
         # gh run list --workflow=build.yml
-        proc = subprocess.Popen(['gh','run', "list", "--workflow=build.yml"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["gh", "run", "list", "--workflow=build.yml"],
+            stdout=subprocess.PIPE,
+            cwd=temp_dir.name,
+        )
         proc.wait()
-        
+
         workflow_line = ""
         if proc.returncode == 0:
             for line in proc.stdout:
@@ -374,13 +557,15 @@ def make_release(version):
                 if RELEASE_VERSION_WITH_V in line:
                     workflow_line = line
                     break
-        
+
         print("workflow line: " + workflow_line)
 
         if workflow_line.startswith("X"):
             raise Exception("release workflow failed")
 
-        proc = subprocess.Popen(['gh','release', "list"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc = subprocess.Popen(
+            ["gh", "release", "list"], stdout=subprocess.PIPE, cwd=temp_dir.name
+        )
         proc.wait()
 
         release_line = ""
@@ -390,7 +575,7 @@ def make_release(version):
                 if RELEASE_VERSION_WITH_V in line:
                     release_line = line
                     break
-        
+
         if release_line != "":
             break
         else:
@@ -398,18 +583,18 @@ def make_release(version):
 
         time.sleep(30)
 
-    # release done, update release 
+    # release done, update release
 
     release_notes = [
         "Install this version of wasmer:",
         "",
         "```sh",
-        "curl https://get.wasmer.io -sSfL | sh -s \"" + RELEASE_VERSION_WITH_V + "\"",
+        'curl https://get.wasmer.io -sSfL | sh -s "' + RELEASE_VERSION_WITH_V + '"',
         "```",
         "",
     ]
 
-    if not(len(added) == 0) and not(len(changed) == 0):
+    if not (len(added) == 0) and not (len(changed) == 0):
         release_notes.append("## What's Changed")
         release_notes.append("")
 
@@ -424,17 +609,27 @@ def make_release(version):
     hash = hash.replace("/", "")
 
     release_notes.append("")
-    release_notes.append("See full list of changes in the [CHANGELOG](https://github.com/wasmerio/wasmer/blob/main/CHANGELOG.md#" + hash + ")")
-
-    proc = subprocess.Popen(['gh','release', "edit", RELEASE_VERSION_WITH_V, "--notes", "\r\n".join(release_notes)], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    release_notes.append(
+        "See full list of changes in the [CHANGELOG](https://github.com/wasmerio/wasmer/blob/main/CHANGELOG.md#"
+        + hash
+        + ")"
+    )
+
+    proc = subprocess.Popen(
+        [
+            "gh",
+            "release",
+            "edit",
+            RELEASE_VERSION_WITH_V,
+            "--notes",
+            "\r\n".join(release_notes),
+        ],
+        stdout=subprocess.PIPE,
+        cwd=temp_dir.name,
+    )
     proc.wait()
 
-    raise Exception("script done and merged")
+    print("Script done and merged 🎉🎉🎉")
 
-try:
-    make_release(RELEASE_VERSION)
-except Exception as err:
-    while True:
-        print(str(err))
-        if os.system("say " + str(err)) != 0:
-            sys.exit()
\ No newline at end of file
+
+make_release(RELEASE_VERSION)
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..42839e9ce4 100644
--- a/scripts/publish.py
+++ b/scripts/publish.py
@@ -18,7 +18,6 @@
 import os
 import re
 import subprocess
-import time
 import sys
 import typing
 from pprint import pprint
@@ -45,13 +44,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 +125,29 @@ 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"])
+
+        def check_local_workspace_dep(t):
+            return (
+                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]
+        def check_local_dep_fn(t):
+            return 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",
@@ -177,7 +197,8 @@ def return_dependencies(toml) -> typing.List[str]:
                                     if "package" in dep[1]
                                     else dep[0],
                                     filter(
-                                        check_local_dep_fn, toml["dev-dependencies"].items()
+                                        check_local_dep_fn,
+                                        toml["dev-dependencies"].items(),
                                     ),
                                 )
                             )
@@ -218,7 +239,7 @@ def is_crate_already_published(self, crate_name: str) -> bool:
 
         if self.version == found_string:
             return True
-        
+
         crate = self.crate_index[crate_name]
         with open(crate.path + "/Cargo.toml", "rb") as file:
             data = tomllib.load(file)
@@ -286,15 +307,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..e298adf20a 100644
--- a/scripts/update-version.py
+++ b/scripts/update-version.py
@@ -1,42 +1,102 @@
 #!/usr/bin/python
 
-PREVIOUS_VERSION='4.3.6'
-NEXT_VERSION='4.3.7'
-
 import os
 import re
 
+PREVIOUS_VERSION = "7.0.0-rc.2"
+NEXT_VERSION = "7.0.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)
+
+
 def replace(file, pattern, subst):
     # Read contents from file as a single string
-    file_handle = open(file, 'r')
+    file_handle = open(file, "r")
     file_string = file_handle.read()
     file_handle.close()
 
     # Use RE package to allow for replacement (also allowing for (multiline) REGEX)
-    file_string = (re.sub(pattern, subst, file_string))
+    file_string = re.sub(pattern, subst, file_string)
 
     # Write contents to file.
     # Using mode 'w' truncates the file.
-    file_handle = open(file, 'w')
+    file_handle = open(file, "w")
     file_handle.write(file_string)
     file_handle.close()
 
+
 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_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_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))
@@ -48,4 +108,4 @@ def replace_version_iss(path):
         elif "publish.py" in file:
             replace_version_py(root + "/" + file)
 
-os.system("cargo generate-lockfile")
\ No newline at end of file
+os.system("cargo generate-lockfile")
diff --git a/scripts/windows-installer/wasmer.iss b/scripts/windows-installer/wasmer.iss
index 5f061f9452..6afc58edef 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=7.0.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..5023f3d185
--- /dev/null
+++ b/tests/c-wasi-tests/Makefile
@@ -0,0 +1,139 @@
+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 \
+	  -lcommon-tag-stubs \
+	  ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/libclang_rt.builtins-wasm32.a \
+	  --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 $@
+
+poll_oneoff_zero.wasm: poll_oneoff_zero.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 \
+	  -lcommon-tag-stubs \
+	  ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/libclang_rt.builtins-wasm32.a \
+	  --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 poll_oneoff_zero.wasm
+	cp -f $^ ../integration/cli/tests/wasm
+
+clean:
+	rm -f *.wasm *.wat *.o *.so
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/poll_oneoff_zero.c b/tests/c-wasi-tests/poll_oneoff_zero.c
new file mode 100644
index 0000000000..6627c3d958
--- /dev/null
+++ b/tests/c-wasi-tests/poll_oneoff_zero.c
@@ -0,0 +1,44 @@
+#include <assert.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <wasi/api_wasi.h>
+
+static atomic_bool done;
+
+static void *worker(void *arg) {
+    (void)arg;
+    __wasi_subscription_t sub = {0};
+    __wasi_event_t out = {0};
+    __wasi_size_t events = 0;
+    const __wasi_size_t nsubscriptions = 0; // Passing a 0 causes an infinite loop
+    __wasi_errno_t ret = __wasi_poll_oneoff(&sub, &out, nsubscriptions, &events);
+    assert(ret == __WASI_ERRNO_INVAL && "poll_oneoff(0) should return EINVAL");
+    atomic_store(&done, true);
+    return NULL;
+}
+
+int main(void) {
+    pthread_t thread;
+    atomic_init(&done, false);
+    assert(pthread_create(&thread, NULL, worker, NULL) == 0 && "pthread_create failed");
+
+    __wasi_timestamp_t start = 0;
+    assert(__wasi_clock_time_get(__WASI_CLOCKID_MONOTONIC, 1, &start)
+               == __WASI_ERRNO_SUCCESS
+           && "clock_time_get failed");
+    while (!atomic_load(&done)) {
+        __wasi_timestamp_t now = 0;
+        assert(__wasi_clock_time_get(__WASI_CLOCKID_MONOTONIC, 1, &now)
+                   == __WASI_ERRNO_SUCCESS
+               && "clock_time_get failed");
+        if (now - start > 1000000000ULL) {
+            assert(0 && "poll_oneoff(0) did not return in time");
+        }
+        sched_yield();
+    }
+
+    assert(pthread_join(thread, NULL) == 0 && "pthread_join failed");
+    return 0;
+}
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..f592b2de7b 100644
--- a/tests/compilers/artifact.rs
+++ b/tests/compilers/artifact.rs
@@ -1,23 +1,26 @@
 use std::{fs, path::PathBuf};
 
-use cfg_if::cfg_if;
-use wasmer::{Engine, Module};
+use anyhow::Result;
 
-#[test]
-fn artifact_serialization_roundtrip() {
+use wasmer::Module;
+use wasmer_types::Features;
+
+#[compiler_test(artifact)]
+fn artifact_serialization_roundtrip(config: crate::Config) -> Result<()> {
     let file_names = ["bash.wasm", "cowsay.wasm", "python-3.11.3.wasm"];
 
     for file_name in file_names {
         let path = PathBuf::from("tests/integration/cli/tests/wasm").join(file_name);
         let wasm_module = fs::read(path).unwrap();
-        let engine = Engine::default();
-        let module = Module::new(&engine, wasm_module).unwrap();
+        let store = config.store();
+        let module = Module::new(&store, wasm_module).unwrap();
         let serialized_bytes = module.serialize().unwrap();
         let deserialized_module =
-            unsafe { Module::deserialize(&engine, serialized_bytes.clone()) }.unwrap();
+            unsafe { Module::deserialize(&store, serialized_bytes.clone()) }.unwrap();
         let reserialized_bytes = deserialized_module.serialize().unwrap();
         assert_eq!(serialized_bytes, reserialized_bytes);
     }
+    Ok(())
 }
 
 // This test is just here to update the compiled objects to their
@@ -26,15 +29,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::{
+        Engine, Module,
+        sys::{
+            CpuFeature, Target, Triple,
+            engine::{NativeEngineExt, get_default_compiler_config},
+        },
+    };
 
     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);
@@ -42,13 +50,11 @@ fn artifact_serialization_build() {
             let path = PathBuf::from("tests/integration/cli/tests/wasm").join(file_name);
             let wasm_module = fs::read(path).unwrap();
             let config = get_default_compiler_config().unwrap();
-            let mut engine = Engine::new(config, target.clone(), Features::default());
-
-            engine.set_hash_algorithm(Some(wasmer_types::HashAlgorithm::Sha256));
+            let engine = Engine::new(config, target.clone(), Features::default());
 
             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 +63,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`.
@@ -73,7 +80,7 @@ fn artifact_deserialization_roundtrip() {
     for file_name in file_names {
         let path = PathBuf::from(base_path).join(file_name);
         let wasm_module_bytes = fs::read(path).unwrap();
-        let engine = Engine::default();
+        let engine = wasmer::Engine::default();
         let module = unsafe { Module::deserialize(&engine, wasm_module_bytes.clone()) }.unwrap();
         let reserialized_bytes = module.serialize().unwrap();
         assert_eq!(wasm_module_bytes.to_vec(), reserialized_bytes);
diff --git a/tests/compilers/config.rs b/tests/compilers/config.rs
index 9673955876..4d7f9b0bf6 100644
--- a/tests/compilers/config.rs
+++ b/tests/compilers/config.rs
@@ -1,6 +1,10 @@
+use std::path::PathBuf;
 use std::sync::Arc;
 use wasmer::sys::Features;
-use wasmer::{CompilerConfig, ModuleMiddleware, Store};
+use wasmer::{
+    Store,
+    sys::{CompilerConfig, ModuleMiddleware},
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Compiler {
@@ -66,12 +70,25 @@ impl Config {
         &self,
         #[allow(unused_variables)] canonicalize_nans: bool,
     ) -> Box<dyn CompilerConfig> {
+        let debug_dir = std::env::var("WASMER_COMPILER_DEBUG_DIR")
+            .ok()
+            .map(PathBuf::from);
+
         match &self.compiler {
             #[cfg(feature = "cranelift")]
             Compiler::Cranelift => {
+                use wasmer_compiler_cranelift::CraneliftCallbacks;
+
                 let mut compiler = wasmer_compiler_cranelift::Cranelift::new();
                 compiler.canonicalize_nans(canonicalize_nans);
                 compiler.enable_verifier();
+                if let Some(mut debug_dir) = debug_dir {
+                    debug_dir.push("cranelift");
+                    compiler.callbacks(Some(
+                        CraneliftCallbacks::new(debug_dir)
+                            .expect("cannot crate debug directory: {debug_dir}"),
+                    ));
+                }
                 self.add_middlewares(&mut compiler);
                 Box::new(compiler)
             }
@@ -80,6 +97,14 @@ impl Config {
                 let mut compiler = wasmer_compiler_llvm::LLVM::new();
                 compiler.canonicalize_nans(canonicalize_nans);
                 compiler.enable_verifier();
+                if let Some(mut debug_dir) = debug_dir {
+                    use wasmer_compiler_llvm::LLVMCallbacks;
+                    debug_dir.push("llvm");
+                    compiler.callbacks(Some(
+                        LLVMCallbacks::new(debug_dir)
+                            .expect("cannot crate debug directory: {debug_dir}"),
+                    ));
+                }
                 self.add_middlewares(&mut compiler);
                 Box::new(compiler)
             }
@@ -88,15 +113,20 @@ impl Config {
                 let mut compiler = wasmer_compiler_singlepass::Singlepass::new();
                 compiler.canonicalize_nans(canonicalize_nans);
                 compiler.enable_verifier();
+                if let Some(mut debug_dir) = debug_dir {
+                    use wasmer_compiler_singlepass::SinglepassCallbacks;
+                    debug_dir.push("singlepass");
+                    compiler.callbacks(Some(
+                        SinglepassCallbacks::new(debug_dir)
+                            .expect("cannot crate debug directory: {debug_dir}"),
+                    ));
+                }
                 self.add_middlewares(&mut compiler);
                 Box::new(compiler)
             }
             #[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/deterministic.rs b/tests/compilers/deterministic.rs
index 83a9a0ef2c..093c16ffeb 100644
--- a/tests/compilers/deterministic.rs
+++ b/tests/compilers/deterministic.rs
@@ -1,11 +1,20 @@
 use anyhow::Result;
-use wasmer::{wat2wasm, Module, Store};
+use wasmer::{CompileError, Module, wat2wasm};
 
-fn compile_and_compare(wasm: &[u8]) -> Result<()> {
-    let store = Store::default();
+fn compile_and_compare(config: crate::Config, wasm: &[u8]) -> Result<()> {
+    let store = config.store();
 
     // compile for first time
-    let module = Module::new(&store, wasm)?;
+    let module = match Module::new(&store, wasm) {
+        Err(CompileError::Validate(message))
+            if message.contains("construct Cranelift ISA for triple: Unsupported") =>
+        {
+            // Skip the test in that case.
+            return Ok(());
+        }
+        Ok(module) => module,
+        Err(e) => return Err(e.into()),
+    };
     let first = module.serialize()?;
 
     // compile for second time
@@ -17,19 +26,19 @@ fn compile_and_compare(wasm: &[u8]) -> Result<()> {
     Ok(())
 }
 
-#[test]
-fn deterministic_empty() -> Result<()> {
+#[compiler_test(deterministic)]
+fn deterministic_empty(config: crate::Config) -> Result<()> {
     let wasm_bytes = wat2wasm(
         br#"
     (module)
     "#,
     )?;
 
-    compile_and_compare(&wasm_bytes)
+    compile_and_compare(config, &wasm_bytes)
 }
 
-#[test]
-fn deterministic_table() -> Result<()> {
+#[compiler_test(deterministic)]
+fn deterministic_table(config: crate::Config) -> Result<()> {
     let wasm_bytes = wat2wasm(
         br#"
 (module
@@ -40,5 +49,5 @@ fn deterministic_table() -> Result<()> {
 "#,
     )?;
 
-    compile_and_compare(&wasm_bytes)
+    compile_and_compare(config, &wasm_bytes)
 }
diff --git a/tests/compilers/imports.rs b/tests/compilers/imports.rs
index 265495d618..92aed9840f 100644
--- a/tests/compilers/imports.rs
+++ b/tests/compilers/imports.rs
@@ -5,8 +5,8 @@
 use anyhow::Result;
 use std::convert::Infallible;
 use std::sync::{
-    atomic::{AtomicUsize, Ordering::SeqCst},
     Arc,
+    atomic::{AtomicUsize, Ordering::SeqCst},
 };
 use wasmer::FunctionEnv;
 use wasmer::Type as ValueType;
@@ -366,7 +366,7 @@ fn static_function_that_fails(config: crate::Config) -> Result<()> {
         Err(InstantiationError::Start(runtime_error)) => {
             assert_eq!(runtime_error.message(), "oops")
         }
-        _ => assert!(false),
+        _ => panic!(),
     }
 
     Ok(())
@@ -419,7 +419,7 @@ fn dynamic_function_with_env_wasmer_env_init_works(config: crate::Config) -> Res
     )?;
     let memory = instance.exports.get_memory("memory")?;
     env.as_mut(&mut store).memory = Some(memory.clone());
-    let f: TypedFunction<(), ()> = instance.exports.get_typed_function(&mut store, "main")?;
+    let f: TypedFunction<(), ()> = instance.exports.get_typed_function(&store, "main")?;
     f.call(&mut store)?;
     Ok(())
 }
@@ -457,14 +457,14 @@ fn multi_use_host_fn_manages_memory_correctly(config: crate::Config) -> Result<(
     let instance1 = Instance::new(&mut store, &module, &imports)?;
     let instance2 = Instance::new(&mut store, &module, &imports)?;
     {
-        let f1: TypedFunction<(), ()> = instance1.exports.get_typed_function(&mut store, "main")?;
+        let f1: TypedFunction<(), ()> = instance1.exports.get_typed_function(&store, "main")?;
         let memory = instance1.exports.get_memory("memory")?;
         env.as_mut(&mut store).memory = Some(memory.clone());
         f1.call(&mut store)?;
     }
     drop(instance1);
     {
-        let f2: TypedFunction<(), ()> = instance2.exports.get_typed_function(&mut store, "main")?;
+        let f2: TypedFunction<(), ()> = instance2.exports.get_typed_function(&store, "main")?;
         let memory = instance2.exports.get_memory("memory")?;
         env.as_mut(&mut store).memory = Some(memory.clone());
         f2.call(&mut store)?;
@@ -506,9 +506,8 @@ fn instance_local_memory_lifetime(config: crate::Config) -> Result<()> {
     };
     let instance = Instance::new(&mut store, &module, &imports)?;
     let set_at: TypedFunction<(i32, i32), ()> =
-        instance.exports.get_typed_function(&mut store, "set_at")?;
-    let get_at: TypedFunction<i32, i32> =
-        instance.exports.get_typed_function(&mut store, "get_at")?;
+        instance.exports.get_typed_function(&store, "set_at")?;
+    let get_at: TypedFunction<i32, i32> = instance.exports.get_typed_function(&store, "get_at")?;
     set_at.call(&mut store, 200, 123)?;
     assert_eq!(get_at.call(&mut store, 200)?, 123);
 
diff --git a/tests/compilers/issues.rs b/tests/compilers/issues.rs
index 7eb051776b..2b7c40c95f 100644
--- a/tests/compilers/issues.rs
+++ b/tests/compilers/issues.rs
@@ -1,5 +1,7 @@
 //! This file is mainly to assure specific issues are working well
-use anyhow::Result;
+
+use anyhow::{Context, Result};
+use itertools::Itertools;
 use wasmer::FunctionEnv;
 use wasmer::*;
 
@@ -88,6 +90,7 @@ fn call_with_static_data_pointers(mut config: crate::Config) -> Result<()> {
         memory: Option<Memory>,
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn banana(
         mut ctx: FunctionEnvMut<Env>,
         a: u64,
@@ -324,14 +327,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);
     }
 
@@ -427,6 +436,8 @@ fn large_number_local(mut config: crate::Config) -> Result<()> {
           i64.add
           local.get 16
           i64.add
+          local.get 512
+          i64.add
         )
       )
     "#;
@@ -439,11 +450,12 @@ 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(())
 }
 
-#[cfg(target_arch = "aarch64")]
+// TODO: the tests fails on RISC-V as the `j` instruction can reach only +- 1MiB offset.
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
 #[compiler_test(issues)]
 /// Singlepass panics on aarch64 for long relocations.
 ///
@@ -460,38 +472,278 @@ fn issue_4519(mut config: crate::Config) -> Result<()> {
     Ok(())
 }
 
-#[cfg(target_arch = "aarch64")]
+// TODO: the tests fails on RISC-V as the `j` instruction can reach only +- 1MiB offset.
+#[cfg(any(target_arch = "x86_64", 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)))
       )
+    "#
+    .to_string();
+
+    let mut store = config.store();
+    let _ = Module::new(&store, wat);
+
+    Ok(())
+}
+
+fn gen_wat_sum_function(arguments: usize) -> String {
+    assert!(arguments > 0);
+    let arg_types = std::iter::repeat_n("i64", arguments).collect_vec();
+    let params = (0..arguments)
+        .map(|idx| format!("(param $p{} i64)", idx + 1))
+        .collect_vec();
+    let fn_body = (2..=arguments)
+        .map(|idx| format!("local.get $p{idx}\ni64.add"))
+        .collect_vec();
+
+    format!(
+        r#"
+    (module
+    (type $sum_t (func (param {}) (result i64)))
+    (func $sum_f (type $sum_t)
+    {}
+    (result i64)
+    local.get $p1
+    {}
+    )
+    (export "sum" (func $sum_f)))
     "#,
-        sdiv64.repeat(REPEATS_TO_REPRODUCE)
+        arg_types.join(" "),
+        params.join(" "),
+        fn_body.join("\n")
+    )
+}
+
+#[compiler_test(issues)]
+fn huge_number_of_arguments_fn(
+    mut config: crate::Config,
+) -> Result<(), Box<dyn std::error::Error>> {
+    for params in [1, 10, 100, 500, 1000] {
+        println!("Testing sum fn with {params} parameters");
+        let mut store = config.store();
+        let wat_body = gen_wat_sum_function(params as usize);
+        let wat = wat2wasm(wat_body.as_bytes())
+            .with_context(|| format!("Cannot build sum function with {params} parameters"))?;
+
+        let mut env = FunctionEnv::new(&mut store, ());
+        let module = Module::new(&store, wat).unwrap();
+        let imports: Imports = imports! {};
+        let instance = Instance::new(&mut store, &module, &imports)?;
+        let args = (1..=params).map(Value::I64).collect_vec();
+        let result = instance
+            .exports
+            .get_function("sum")?
+            .call(&mut store, &args)
+            .unwrap();
+        assert_eq!(&Value::I64((1..=params).sum()), result.first().unwrap());
+    }
+
+    Ok(())
+}
+
+#[cfg(feature = "llvm")]
+#[compiler_test(issues)]
+fn compiler_debug_dir_test(mut config: crate::Config) {
+    use tempfile::TempDir;
+    use wasmer_compiler::EngineBuilder;
+    use wasmer_compiler_llvm::LLVMCallbacks;
+
+    let mut compiler_config = wasmer_compiler_llvm::LLVM::default();
+    let temp = TempDir::new().expect("temp folder creation failed");
+    compiler_config.callbacks(Some(LLVMCallbacks::new(temp.path().to_path_buf()).unwrap()));
+    let mut store = Store::new(EngineBuilder::new(compiler_config));
+
+    let mut wat = include_str!("../wast/spec/fac.wast").to_string();
+    wat.truncate(
+        wat.find("(assert_return")
+            .expect("assert expected in the test"),
     );
 
+    assert!(Module::new(&store, wat).is_ok());
+}
+
+#[compiler_test(issues)]
+fn issue_5795_memory_reset_size(mut config: crate::Config) {
+    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(),
+    )
+    .expect("wat2wasm must succeed");
+
     let mut store = config.store();
-    let module = Module::new(&store, wat)?;
+    let module = Module::new(&store, wasm_bytes).unwrap();
+    let instance = Instance::new(&mut store, &module, &imports! {}).unwrap();
+    let memory = instance.exports.get_memory("memory").unwrap();
 
-    Ok(())
+    let _ = memory.grow(&mut store, 999).unwrap();
+    memory.reset(&mut store);
+
+    assert_eq!(memory.size(&store).bytes().0, 0);
+    assert_eq!(memory.view(&store).size().0, 0);
+
+    assert_eq!(memory.grow(&mut store, 1).unwrap().0, 0);
+
+    assert_eq!(memory.view(&store).size().0, 1);
+}
+
+#[cfg(not(target_os = "windows"))]
+#[compiler_test(issues)]
+fn issue_6004_exception(mut config: crate::Config) {
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (tag $e)
+
+  (func (export "throw-expect-42") (result i32)
+    (block $h1 (result exnref)
+      (try_table (result exnref) (catch_all_ref $h1)
+        (block $h2 (result exnref)
+          (try_table (result exnref) (catch_ref $e $h2)
+            (throw $e)
+          )
+        )
+        (i32.const 42)
+        (return)
+      )
+    )
+    (drop)
+    (i32.const 1)
+  )
+)
+"#
+        .as_bytes(),
+    )
+    .expect("wat2wasm must succeed");
+
+    let mut store = config.store();
+    let module = match Module::new(&store, wasm_bytes) {
+        Err(CompileError::Validate(message))
+            if message.contains("exceptions proposal not enabled") =>
+        {
+            // Skip the test in that case.
+            return;
+        }
+        Ok(module) => module,
+        _ => unreachable!(),
+    };
+    let instance = Instance::new(&mut store, &module, &imports! {}).unwrap();
+    let result = instance
+        .exports
+        .get_function("throw-expect-42")
+        .unwrap()
+        .call(&mut store, &[])
+        .unwrap();
+    assert_eq!(&Value::I32(42), result.first().unwrap());
+}
+
+#[cfg(not(target_os = "windows"))]
+#[compiler_test(issues)]
+fn issue_5719_shared_catch_clause_block(mut config: crate::Config) {
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+    (tag $err (param))
+    (tag $err2 (param))
+    (export "f" (func $f))
+    (func $f (result i32)
+        block
+            block
+                try_table (catch $err 0) (catch $err2 0)
+                    throw $err2
+                end
+                unreachable
+            end
+            i32.const 42
+            return
+        end
+        i32.const 13
+        return
+    )
+)
+"#
+        .as_bytes(),
+    )
+    .expect("wat2wasm must succeed");
+
+    let mut store = config.store();
+    let module = match Module::new(&store, wasm_bytes) {
+        Err(CompileError::Validate(message))
+            if message.contains("exceptions proposal not enabled") =>
+        {
+            // Skip the test in that case.
+            return;
+        }
+        Ok(module) => module,
+        _ => unreachable!(),
+    };
+    let instance = Instance::new(&mut store, &module, &imports! {}).unwrap();
+    let result = instance
+        .exports
+        .get_function("f")
+        .unwrap()
+        .call(&mut store, &[])
+        .unwrap();
+    assert_eq!(&Value::I32(42), result.first().unwrap());
 }
diff --git a/tests/compilers/main.rs b/tests/compilers/main.rs
index 573800efc4..984712bce4 100644
--- a/tests/compilers/main.rs
+++ b/tests/compilers/main.rs
@@ -5,14 +5,15 @@
 #[macro_use]
 extern crate compiler_test_derive;
 
+mod artifact;
 mod config;
 mod deterministic;
 mod imports;
 mod issues;
 mod metering;
 mod middlewares;
-// mod multi_value_imports;
-mod artifact;
+mod multi_value_imports;
+mod progress;
 mod serialize;
 mod traps;
 mod typed_functions;
diff --git a/tests/compilers/metering.rs b/tests/compilers/metering.rs
index 8d5855b54f..8e8f8207d5 100644
--- a/tests/compilers/metering.rs
+++ b/tests/compilers/metering.rs
@@ -2,8 +2,8 @@ use anyhow::Result;
 use wasmer_middlewares::Metering;
 
 use std::sync::Arc;
-use wasmer::wasmparser::Operator;
 use wasmer::FunctionEnv;
+use wasmer::wasmparser::Operator;
 use wasmer::*;
 
 fn cost_always_one(_: &Operator) -> u64 {
@@ -26,8 +26,7 @@ fn run_add_with_limit(mut config: crate::Config, limit: u64) -> Result<()> {
     let module = Module::new(&store, wat).unwrap();
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add")?;
+    let f: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
     f.call(&mut store, 4, 6)?;
     Ok(())
 }
@@ -58,7 +57,7 @@ fn run_loop(mut config: crate::Config, limit: u64, iter_count: i32) -> Result<()
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<i32, ()> = instance.exports.get_typed_function(&mut store, "test")?;
+    let f: TypedFunction<i32, ()> = instance.exports.get_typed_function(&store, "test")?;
     f.call(&mut store, iter_count)?;
     Ok(())
 }
@@ -111,41 +110,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))
@@ -163,7 +162,7 @@ fn complex_loop(mut config: crate::Config) -> Result<()> {
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add_to")?;
+        instance.exports.get_typed_function(&store, "add_to")?;
 
     // FIXME: Since now a metering error is signaled with an `unreachable`, it is impossible to verify
     // the error type. Fix this later.
diff --git a/tests/compilers/middlewares.rs b/tests/compilers/middlewares.rs
index 393545098d..2ecdda64d5 100644
--- a/tests/compilers/middlewares.rs
+++ b/tests/compilers/middlewares.rs
@@ -1,9 +1,9 @@
 use anyhow::Result;
 
 use std::sync::Arc;
-use wasmer::wasmparser::Operator;
 use wasmer::FunctionEnv;
-use wasmer::*;
+use wasmer::wasmparser::Operator;
+use wasmer::{sys::*, *};
 
 #[derive(Debug)]
 struct Add2MulGen {
@@ -112,8 +112,7 @@ fn middleware_basic(mut config: crate::Config) -> Result<()> {
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add")?;
+    let f: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
     let result = f.call(&mut store, 4, 6)?;
     assert_eq!(result, 24);
     Ok(())
@@ -136,8 +135,7 @@ fn middleware_one_to_multi(mut config: crate::Config) -> Result<()> {
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add")?;
+    let f: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
     let result = f.call(&mut store, 4, 6)?;
     assert_eq!(result, 25);
     Ok(())
@@ -161,9 +159,8 @@ fn middleware_multi_to_one(mut config: crate::Config) -> Result<()> {
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> = instance
-        .exports
-        .get_typed_function(&mut store, "testfunc")?;
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&store, "testfunc")?;
     let result = f.call(&mut store, 10, 20)?;
     assert_eq!(result, 10);
     Ok(())
@@ -186,8 +183,7 @@ fn middleware_chain_order_1(mut config: crate::Config) -> Result<()> {
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add")?;
+    let f: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
     let result = f.call(&mut store, 4, 6)?;
     assert_eq!(result, 24);
     Ok(())
@@ -210,8 +206,7 @@ fn middleware_chain_order_2(mut config: crate::Config) -> Result<()> {
 
     let instance = Instance::new(&mut store, &module, &import_object)?;
 
-    let f: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_typed_function(&mut store, "add")?;
+    let f: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
     let result = f.call(&mut store, 4, 6)?;
     assert_eq!(result, 48);
     Ok(())
diff --git a/tests/compilers/multi_value_imports.rs b/tests/compilers/multi_value_imports.rs
index 26f291938b..d570c628f8 100644
--- a/tests/compilers/multi_value_imports.rs
+++ b/tests/compilers/multi_value_imports.rs
@@ -2,21 +2,20 @@
 //! This tests checks that the provided functions (both native and
 //! dynamic ones) work properly.
 
-use wasmer::*;
-
 macro_rules! mvr_test {
     ($test_name:ident, $( $result_type:ty ),* ) => {
         mod $test_name {
             use wasmer::*;
+            use crate::multi_value_imports::ExpectedExpr;
 
-            fn get_module(store: &Store) -> anyhow::Result<wasmer::Module> {
+            fn get_module(store: &Store) -> anyhow::Result<Module> {
                 let wat: String = r#"
   (type $type (func (param i32) (result
 "#.to_string() +
                     &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)
@@ -28,7 +27,7 @@ macro_rules! mvr_test {
     )
   )
 "#.to_string();
-                Ok(wasmer::Module::new(&store, &wat)?)
+                Ok(Module::new(&store, &wat)?)
             }
 
             fn callback_fn(n: i32) -> ( $( $result_type ),* ) {
@@ -39,24 +38,22 @@ macro_rules! mvr_test {
             fn native(config: crate::Config) -> anyhow::Result<()> {
                 let mut store = config.store();
                 let module = get_module(&store)?;
-                let instance = wasmer::Instance::new(
-                    &module,
-                    &wasmer::imports! {
-                        "host" => {
-                            "callback_fn" => wasmer::Function::new_native(&store, callback_fn)
-                        }
+                let imports = imports! {
+                    "host" => {
+                        "callback_fn" => Function::new_typed(&mut store, callback_fn),
                     }
-                )?;
+                };
+                let instance = Instance::new(&mut store, &module, &imports)?;
                 let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice();
-                assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?,
+                assert_eq!(instance.exports.get_function("test_call")?.call(&mut store, &[Value::I32(1)])?,
                            expected_value);
-                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?,
+                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&mut store, &[Value::I32(1)])?,
                            expected_value);
                 Ok(())
             }
 
-            fn dynamic_callback_fn(values: &[wasmer::Value]) -> anyhow::Result<Vec<wasmer::Val>, wasmer::RuntimeError> {
-                assert_eq!(values[0], wasmer::Value::I32(1));
+            fn dynamic_callback_fn(values: &[Value]) -> anyhow::Result<Vec<Value>, RuntimeError> {
+                assert_eq!(values[0], Value::I32(1));
                 Ok(vec![ $( <$result_type>::expected_val(1) ),* ])
             }
 
@@ -64,19 +61,17 @@ macro_rules! mvr_test {
             fn dynamic(config: crate::Config) -> anyhow::Result<()> {
                 let mut store = config.store();
                 let module = get_module(&store)?;
-                let callback_fn = wasmer::Function::new(&store, &wasmer::FunctionType::new(vec![wasmer::ValType::I32], vec![ $( <$result_type>::expected_valtype() ),* ]), dynamic_callback_fn);
-                let instance = wasmer::Instance::new(
-                    &module,
-                    &wasmer::imports! {
-                        "host" => {
-                            "callback_fn" => callback_fn
-                        }
+                let callback_fn = Function::new(& mut store, &FunctionType::new(vec![Type::I32], vec![ $( <$result_type>::expected_valtype() ),* ]), dynamic_callback_fn);
+                let imports = imports! {
+                    "host" => {
+                        "callback_fn" => callback_fn
                     }
-                )?;
+                };
+                let instance = Instance::new(&mut store, &module, &imports)?;
                 let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice();
-                assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?,
+                assert_eq!(instance.exports.get_function("test_call")?.call(&mut store, &[Value::I32(1)])?,
                            expected_value);
-                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?,
+                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&mut store, &[Value::I32(1)])?,
                            expected_value);
                 Ok(())
             }
@@ -84,53 +79,55 @@ macro_rules! mvr_test {
     }
 }
 
+use wasmer::{Type, Value};
+
 trait ExpectedExpr {
     fn expected_value(n: i32) -> Self;
-    fn expected_val(n: i32) -> wasmer::Val;
-    fn expected_valtype() -> wasmer::ValType;
+    fn expected_val(n: i32) -> Value;
+    fn expected_valtype() -> Type;
 }
 impl ExpectedExpr for i32 {
     fn expected_value(n: i32) -> i32 {
         n + 1
     }
-    fn expected_val(n: i32) -> wasmer::Val {
-        wasmer::Val::I32(Self::expected_value(n))
+    fn expected_val(n: i32) -> Value {
+        Value::I32(Self::expected_value(n))
     }
-    fn expected_valtype() -> wasmer::ValType {
-        wasmer::ValType::I32
+    fn expected_valtype() -> Type {
+        Type::I32
     }
 }
 impl ExpectedExpr for i64 {
     fn expected_value(n: i32) -> i64 {
         n as i64 + 2i64
     }
-    fn expected_val(n: i32) -> wasmer::Val {
-        wasmer::Val::I64(Self::expected_value(n))
+    fn expected_val(n: i32) -> Value {
+        Value::I64(Self::expected_value(n))
     }
-    fn expected_valtype() -> wasmer::ValType {
-        wasmer::ValType::I64
+    fn expected_valtype() -> Type {
+        Type::I64
     }
 }
 impl ExpectedExpr for f32 {
     fn expected_value(n: i32) -> f32 {
         n as f32 * 0.1
     }
-    fn expected_val(n: i32) -> wasmer::Val {
-        wasmer::Val::F32(Self::expected_value(n))
+    fn expected_val(n: i32) -> Value {
+        Value::F32(Self::expected_value(n))
     }
-    fn expected_valtype() -> wasmer::ValType {
-        wasmer::ValType::F32
+    fn expected_valtype() -> Type {
+        Type::F32
     }
 }
 impl ExpectedExpr for f64 {
     fn expected_value(n: i32) -> f64 {
         n as f64 * 0.12
     }
-    fn expected_val(n: i32) -> wasmer::Val {
-        wasmer::Val::F64(Self::expected_value(n))
+    fn expected_val(n: i32) -> Value {
+        Value::F64(Self::expected_value(n))
     }
-    fn expected_valtype() -> wasmer::ValType {
-        wasmer::ValType::F64
+    fn expected_valtype() -> Type {
+        Type::F64
     }
 }
 
@@ -203,3 +200,270 @@ mvr_test!(test_mvr_f32_f32_f32_i32, f32, f32, f32, i32);
 mvr_test!(test_mvr_f32_f32_f32_f32, f32, f32, f32, f32);
 
 mvr_test!(test_mvr_i32_i32_i32_i32_i32, i32, i32, i32, i32, i32);
+mvr_test!(test_mvr_i32_i32_i64_i64_i32, i32, i32, i64, i64, i32);
+
+mvr_test!(
+    test_mvr_i32_i64_f32_f64_i32_f32_i64_f32,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    f32,
+    i64,
+    f32
+);
+mvr_test!(
+    test_mvr_f32_i32_i64_f64_f32_i64_i32_f32_f64,
+    f32,
+    i32,
+    i64,
+    f64,
+    f32,
+    i64,
+    i32,
+    f32,
+    f64
+);
+mvr_test!(
+    test_mvr_i64_i32_f32_f64_i32_i32_f32_i64_f64_f32,
+    i64,
+    i32,
+    f32,
+    f64,
+    i32,
+    i32,
+    f32,
+    i64,
+    f64,
+    f32
+);
+mvr_test!(
+    test_mvr_f64_f32_i32_i64_f32_i32_f64_i64_f32_i32_f64,
+    f64,
+    f32,
+    i32,
+    i64,
+    f32,
+    i32,
+    f64,
+    i64,
+    f32,
+    i32,
+    f64
+);
+mvr_test!(
+    test_mvr_i32_f32_f64_i64_i32_f32_i64_f64_i32_f32_i64_f64,
+    i32,
+    f32,
+    f64,
+    i64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64
+);
+mvr_test!(
+    test_mvr_f32_i64_i32_f64_f32_i64_i32_f32_f64_i64_i32_f32_f64,
+    f32,
+    i64,
+    i32,
+    f64,
+    f32,
+    i64,
+    i32,
+    f32,
+    f64,
+    i64,
+    i32,
+    f32,
+    f64
+);
+mvr_test!(
+    test_mvr_i64_f64_f32_i32_i64_f32_f64_i32_f32_i64_f64_i32_f32_i64,
+    i64,
+    f64,
+    f32,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64
+);
+mvr_test!(
+    test_mvr_f32_f32_i32_i64_f64_i32_f32_i64,
+    f32,
+    f32,
+    i32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64
+);
+mvr_test!(
+    test_mvr_i32_f32_i64_f64_i32_f32_i64_f64_i32,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32
+);
+mvr_test!(
+    test_mvr_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64
+);
+mvr_test!(
+    test_mvr_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32
+);
+mvr_test!(
+    test_mvr_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64
+);
+
+mvr_test!(
+    test_mvr_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64_i32_f32_i64_f64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64,
+    i32,
+    f32,
+    i64,
+    f64
+);
+
+mvr_test!(
+    test_mvr_i64_f32_f64_i32_i64_f32_f64_i32_i64_f32_f64_i32_i64_f32_f64_i32_i64_f32_f64_i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32,
+    i64,
+    f32,
+    f64,
+    i32
+);
+
+mvr_test!(
+    test_mvr_f32_i32_f64_i64_f32_i32_f64_i64_f32_i32_f64_i64_f32_i32_f64_i64_f32_i32,
+    f32,
+    i32,
+    f64,
+    i64,
+    f32,
+    i32,
+    f64,
+    i64,
+    f32,
+    i32,
+    f64,
+    i64,
+    f32,
+    i32,
+    f64,
+    i64,
+    f32,
+    i32
+);
+
+mvr_test!(
+    test_mvr_f64_f32_i64_i32_f64_f32_i64_i32_f64_f32_i64_i32_f64_f32_i64_i32,
+    f64,
+    f32,
+    i64,
+    i32,
+    f64,
+    f32,
+    i64,
+    i32,
+    f64,
+    f32,
+    i64,
+    i32,
+    f64,
+    f32,
+    i64,
+    i32
+);
diff --git a/tests/compilers/progress.rs b/tests/compilers/progress.rs
new file mode 100644
index 0000000000..2f4dda42c4
--- /dev/null
+++ b/tests/compilers/progress.rs
@@ -0,0 +1,63 @@
+use anyhow::Result;
+use std::sync::{Arc, Mutex};
+
+use wasmer::{sys::NativeEngineExt, wat2wasm};
+use wasmer_types::{CompilationProgressCallback, CompileError, UserAbort};
+
+const SIMPLE_WAT: &str = r#"(module
+  (import "env" "div" (func $div (param i32 i32) (result i32)))
+  (func (export "add") (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    i32.add)
+  (func (export "sub") (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    i32.sub)
+)"#;
+
+fn wasm_bytes() -> Vec<u8> {
+    wat2wasm(SIMPLE_WAT.as_bytes()).expect("valid wat").to_vec()
+}
+#[compiler_test(issues)]
+fn reports_progress_steps(mut config: crate::Config) -> Result<()> {
+    let engine = config.store();
+    let wasm = wasm_bytes();
+
+    let events = Arc::new(Mutex::new(Vec::new()));
+    let cb = CompilationProgressCallback::new({
+        let events = events.clone();
+        move |progress| {
+            events.lock().unwrap().push(progress);
+            Ok(())
+        }
+    });
+
+    engine
+        .engine()
+        .new_module_with_progress(&wasm, cb)
+        .expect("compilation succeeds");
+
+    let events = events.lock().unwrap();
+    assert!(
+        !events.is_empty(),
+        "expected at least one progress notification"
+    );
+    let last = events.last().unwrap();
+    assert_eq!(last.phase_step_count(), Some(4));
+    assert_eq!(last.phase_step(), Some(4));
+    Ok(())
+}
+
+#[compiler_test(issues)]
+fn progress_can_abort(mut config: crate::Config) -> Result<()> {
+    let engine = config.store();
+    let wasm = wasm_bytes();
+
+    let cb = CompilationProgressCallback::new(|_| Err(UserAbort::new("abort")));
+    match engine.engine().new_module_with_progress(&wasm, cb) {
+        Err(CompileError::Aborted(e)) => assert_eq!(e.reason(), "abort"),
+        other => panic!("expected CompileError::Aborted, got {:?}", other),
+    }
+    Ok(())
+}
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..61a0fda024 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,10 @@ 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"));
+    #[allow(clippy::unused_unit)]
+    let f0 = Function::new_typed(&mut store, || -> () {
+        panic!("this is another panic");
+    });
     let instance = Instance::new(
         &mut store,
         &module,
@@ -359,7 +362,10 @@ 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"));
+    #[allow(clippy::unused_unit)]
+    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 +428,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 +436,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 +463,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 +491,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..17754291b4 100644
--- a/tests/compilers/typed_functions.rs
+++ b/tests/compilers/typed_functions.rs
@@ -8,6 +8,7 @@ use wasmer::FunctionEnv;
 use wasmer::Type as ValueType;
 use wasmer::*;
 
+#[allow(clippy::too_many_arguments)]
 fn long_f(a: u32, b: u32, c: u32, d: u32, e: u32, f: u16, g: u64, h: u64, i: u16, j: u32) -> u64 {
     j as u64
         + i as u64 * 10
@@ -60,7 +61,7 @@ fn typed_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> {
 
     {
         let f: TypedFunction<(i32, i32), i32> =
-            instance.exports.get_typed_function(&mut store, "add")?;
+            instance.exports.get_typed_function(&store, "add")?;
         let result = f.call(&mut store, 4, 6)?;
         assert_eq!(result, 10);
     }
@@ -73,7 +74,7 @@ fn typed_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> {
 
     {
         let dyn_f: &Function = instance.exports.get("double_then_add")?;
-        let f: TypedFunction<(i32, i32), i32> = dyn_f.typed(&mut store).unwrap();
+        let f: TypedFunction<(i32, i32), i32> = dyn_f.typed(&store).unwrap();
         let result = f.call(&mut store, 4, 6)?;
         assert_eq!(result, 20);
     }
@@ -86,7 +87,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 +101,7 @@ fn typed_with_env_host_function_closure_panics(config: crate::Config) {
         &mut store,
         &env,
         move |_env: FunctionEnvMut<i32>, _: i32| {
-            println!("{}", state);
+            println!("{state}");
         },
     );
 }
@@ -156,7 +157,7 @@ fn non_typed_functions_and_closures_with_no_env_work(config: crate::Config) -> a
     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")?;
+        instance.exports.get_typed_function(&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;
@@ -185,15 +186,16 @@ fn typed_function_works_for_wasm_function_manyparams(config: crate::Config) -> a
 
     {
         let dyn_f: &Function = instance.exports.get("longf")?;
-        let f: TypedFunction<(), i64> = dyn_f.typed(&mut store).unwrap();
+        let f: TypedFunction<(), i64> = dyn_f.typed(&store).unwrap();
         let result = f.call(&mut store)?;
         assert_eq!(result, 1234567890);
     }
 
     {
         let dyn_f: &Function = instance.exports.get("longf_pure")?;
+        #[allow(clippy::type_complexity)]
         let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
-            dyn_f.typed(&mut store).unwrap();
+            dyn_f.typed(&store).unwrap();
         let result = f.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
         assert_eq!(result, 1234567890);
     }
@@ -225,15 +227,16 @@ fn typed_function_works_for_wasm_function_manyparams_dynamic(
 
     {
         let dyn_f: &Function = instance.exports.get("longf")?;
-        let f: TypedFunction<(), i64> = dyn_f.typed(&mut store).unwrap();
+        let f: TypedFunction<(), i64> = dyn_f.typed(&store).unwrap();
         let result = f.call(&mut store)?;
         assert_eq!(result, 1234567890);
     }
 
     {
         let dyn_f: &Function = instance.exports.get("longf_pure")?;
+        #[allow(clippy::type_complexity)]
         let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
-            dyn_f.typed(&mut store).unwrap();
+            dyn_f.typed(&store).unwrap();
         let result = f.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
         assert_eq!(result, 1234567890);
     }
@@ -253,6 +256,7 @@ fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()>
         Ok((d * 4.0, c * 3.0, b * 2, a))
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn long_f(
         a: u32,
         b: u32,
@@ -275,8 +279,9 @@ fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()>
     // Native static host function that returns a tuple.
     {
         let f = Function::new_typed(&mut store, f);
+        #[allow(clippy::type_complexity)]
         let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.typed(&mut store).unwrap();
+            f.typed(&store).unwrap();
         let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
         assert_eq!(result, (28.0, 15.0, 6, 1));
     }
@@ -284,19 +289,21 @@ fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()>
     // Native static host function that returns a tuple.
     {
         let long_f = Function::new_typed(&mut store, long_f);
+        #[allow(clippy::type_complexity)]
         let long_f_typed: TypedFunction<
             (u32, u32, u32, u32, u32, u16, u64, u64, u16, u32),
             (u32, u64, u32),
-        > = long_f.typed(&mut store).unwrap();
+        > = long_f.typed(&store).unwrap();
         let result = long_f_typed.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
-        assert_eq!(result, (654321, 87, 09));
+        assert_eq!(result, (654321, 87, 9));
     }
 
     // Native static host function that returns a result of a tuple.
     {
         let f = Function::new_typed(&mut store, f_ok);
+        #[allow(clippy::type_complexity)]
         let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.typed(&mut store).unwrap();
+            f.typed(&store).unwrap();
         let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
         assert_eq!(result, (28.0, 15.0, 6, 1));
     }
@@ -346,8 +353,9 @@ fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
         let mut env = FunctionEnv::new(&mut store, env);
 
         let f = Function::new_typed_with_env(&mut store, &env, f);
+        #[allow(clippy::type_complexity)]
         let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.typed(&mut store).unwrap();
+            f.typed(&store).unwrap();
 
         assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
 
@@ -363,8 +371,9 @@ fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
         let mut env = FunctionEnv::new(&mut store, env);
 
         let f = Function::new_typed_with_env(&mut store, &env, f_ok);
+        #[allow(clippy::type_complexity)]
         let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.typed(&mut store).unwrap();
+            f.typed(&store).unwrap();
 
         assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
 
@@ -405,8 +414,9 @@ fn dynamic_host_function_without_env(config: crate::Config) -> anyhow::Result<()
             ])
         },
     );
+    #[allow(clippy::type_complexity)]
     let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-        f.typed(&mut store).unwrap();
+        f.typed(&store).unwrap();
     let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
 
     assert_eq!(result, (28.0, 15.0, 6, 1));
@@ -462,8 +472,9 @@ fn dynamic_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
         },
     );
 
+    #[allow(clippy::type_complexity)]
     let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-        f.typed(&mut store).unwrap();
+        f.typed(&store).unwrap();
 
     assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
 
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..cdb734fd46 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..f6884384eb 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..ba940d775e 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..9e656fb742 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..4420a8b36b 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..11a6a7ad89 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..c637d8a32d 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,8 +33,9 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
     if is_threads {
         features.threads(true);
     }
-    if config.compiler == crate::Compiler::Singlepass {
-        features.multi_value(false);
+
+    if is_exception_handling {
+        features.exceptions(true);
     }
     config.set_features(features);
     config.set_nan_canonicalization(try_nan_canonicalization);
@@ -49,26 +51,21 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
     if cfg!(feature = "coverage") {
         wast.disable_assert_and_exhaustion();
     }
+
+    wast.allow_instantiation_failures(&["Validation error: memory size must be at most"]);
     if is_simd {
         // We allow this, so tests can be run properly for `simd_const` test.
         wast.allow_instantiation_failures(&[
             "Validation error: multiple tables",
             "Validation error: unknown memory 0",
             "Validation error: Invalid var_u32",
+            "Validation error: SIMD index out of bounds",
         ]);
     }
     if is_threads {
         // We allow this, so tests can be run properly for `simd_const` test.
         wast.allow_instantiation_failures(&["Validation error: multiple tables"]);
     }
-    if config.compiler == crate::Compiler::Singlepass {
-        // We don't support multivalue yet in singlepass
-        wast.allow_instantiation_failures(&[
-            "Validation error: invalid result arity: func type returns multiple values",
-            "Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled",
-            "Validation error: func type returns multiple values but the multi-value feature is not enabled",
-        ]);
-    }
     wast.fail_fast = false;
     let path = Path::new(wast_path);
     wast.run_file(path)
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/jspi.wat b/tests/examples/jspi.wat
new file mode 100644
index 0000000000..71ed9b5718
--- /dev/null
+++ b/tests/examples/jspi.wat
@@ -0,0 +1,14 @@
+(module
+  (import "js" "init_state" (func $init_state (result f64)))
+  (import "js" "compute_delta" (func $compute_delta (result f64)))
+  (global $state (mut f64) (f64.const 0))
+  (func $init (global.set $state (call $init_state)))
+  (start $init)
+  (func $get_state (export "get_state") (result f64) (global.get $state))
+  (func $update_state (export "update_state") (result f64)
+    (local $delta f64)
+    (local.set $delta (call $compute_delta))
+    (global.set $state (f64.add (global.get $state) (local.get $delta) ))
+    (global.get $state)
+  )
+)
\ No newline at end of file
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/simple-greenthread.wat b/tests/examples/simple-greenthread.wat
new file mode 100644
index 0000000000..5984086a54
--- /dev/null
+++ b/tests/examples/simple-greenthread.wat
@@ -0,0 +1,101 @@
+(module
+  (import "test" "log" (func $log (param i32 i32)))
+  (import "test" "greenthread_new" (func $greenthread_new (param i32) (result i32)))
+  (import "test" "greenthread_switch" (func $greenthread_switch (param i32)))
+  
+  
+  (memory (export "memory") 1)
+  
+  (data (i32.const 0) "[gr1] main  -> test1")
+  (data (i32.const 100) "[gr1] test1 <- test2")
+  (data (i32.const 200) "[gr2] test1 -> test2")
+  (data (i32.const 300) "[main] main <- test1")
+
+  (global $main (mut i32) (i32.const 0))
+  (global $gr1 (mut i32) (i32.const 0))
+  (global $gr2 (mut i32) (i32.const 0))
+  
+  (func (export "_main")
+    i32.const 0  
+    global.set $main
+    (call $greenthread_new (i32.const 0))
+    global.set $gr1
+    (call $greenthread_new (i32.const 1))
+    global.set $gr2
+
+    ;; Switch to gr1
+    global.get $gr1
+    (call $greenthread_switch)
+
+    ;; Print [main] main <- test1
+    i32.const 300  
+    i32.const 20 
+    call $log
+  )
+  (func $gr1 
+    ;; Print [gr1] main  -> test1
+    i32.const 0
+    i32.const 20   
+    call $log
+
+    ;; Switch to gr2
+    global.get $gr2
+    call $greenthread_switch
+
+    ;; Print [gr1] test1 <- test2
+    i32.const 100
+    i32.const 20  
+    call $log
+
+    ;; Switch to gr2
+    global.get $gr2
+    call $greenthread_switch
+
+    ;; Print [gr1] test1 <- test2
+    i32.const 100
+    i32.const 20  
+    call $log
+
+    ;; Switch back to main
+    global.get $main
+    call $greenthread_switch
+    unreachable
+  )
+  (func $gr2 
+    ;; Print [gr2] test1 -> test2
+    i32.const 200  
+    i32.const 20 
+    call $log
+
+    ;; Switch to gr1
+    global.get $gr1
+    call $greenthread_switch
+
+    ;; Print [gr2] test1 -> test2
+    i32.const 200  
+    i32.const 20 
+    call $log
+
+    ;; Switch to gr1
+    global.get $gr1
+    call $greenthread_switch
+
+    unreachable
+  )
+  (func (export "entrypoint") (param i32) 
+    local.get 0
+    i32.const 0
+    i32.eq
+    (if
+      (then
+    (call $gr1)
+  )
+  (else
+    (call $gr2)
+  ))
+  unreachable
+    
+    
+  )
+
+)
diff --git a/tests/examples/simple-greenthread2.wat b/tests/examples/simple-greenthread2.wat
new file mode 100644
index 0000000000..064bb671d1
--- /dev/null
+++ b/tests/examples/simple-greenthread2.wat
@@ -0,0 +1,75 @@
+;; This example crashed in early versions of our async API because switching from the first context to another one worked only once.
+(module
+  (import "test" "log" (func $log (param i32 i32)))
+  (import "test" "greenthread_new" (func $greenthread_new (param i32) (result i32)))
+  (import "test" "greenthread_switch" (func $greenthread_switch (param i32)))
+  
+  (memory (export "memory") 1)
+  
+  (data (i32.const 0) "[main] switching to side")
+  (data (i32.const 100) "[side] switching to main")
+  (data (i32.const 200) "[main] returned")
+
+  (global $main (mut i32) (i32.const 0))
+  (global $side (mut i32) (i32.const 0))
+  
+  (func (export "_main")
+    ;; Setup thread ids
+    i32.const 0  
+    global.set $main
+    (call $greenthread_new (i32.const 0))
+    global.set $side
+
+    ;; Print [main] switching to side
+    i32.const 0
+    i32.const 30   
+    call $log
+
+    ;; Switch to side
+    global.get $side
+    (call $greenthread_switch)
+
+    ;; Print [main] switching to side
+    i32.const 0
+    i32.const 30
+    call $log
+
+    ;; Switch to side
+    global.get $side
+    (call $greenthread_switch)
+
+    ;; Print [main] returned
+    i32.const 200
+    i32.const 30
+    call $log
+  )
+  (func $side 
+    ;; Print [side] switching to main
+    i32.const 100
+    i32.const 30   
+    call $log
+
+    ;; Switch to main
+    global.get $main
+    call $greenthread_switch
+
+    ;; Print [side] switching to main
+    i32.const 100
+    i32.const 30   
+    call $log
+
+    ;; Switch to main
+    global.get $main
+    call $greenthread_switch
+
+    unreachable
+  )
+  (func (export "entrypoint") (param i32) 
+    local.get 0
+    i32.const 0
+    i32.eq
+    call $side
+    unreachable
+  )
+
+)
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..c671963d48 100644
--- a/tests/ignores.txt
+++ b/tests/ignores.txt
@@ -1,5 +1,11 @@
 # Compilers
 singlepass spec::simd # Singlepass doesn't support yet SIMD (no one asked for this feature)
+singlepass wasmer::simd_generated_ext_ops
+singlepass wasmer::simd
+singlepass spec::exception_handling # Singlepass doesn't support EH yet (no one asked for this feature)
+singlepass wasmer::exception_handling
+windows spec::exception_handling # No EH support on Windows yet
+macos+cranelift spec::exception_handling
 
 # Traps
 ## Traps. Tracing doesn't work properly in Singlepass
@@ -9,10 +15,12 @@ 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
 windows    trap_display_pretty
+windows    traps::test_trap_trace
 cranelift+aarch64+macos    traps::trap_display_pretty
 singlepass+aarch64+macos traps::trap_display_multi_module
 llvm       traps::trap_display_multi_module
@@ -29,6 +37,9 @@ 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
+# Codegen("trampoline generation produced relocations")
+llvm+windows      issues::huge_number_of_arguments_fn
 
 # riscv support is still early, function call ABI needs some work
 llvm+riscv64      static_function::llvm::universal
@@ -46,15 +57,50 @@ llvm+riscv64      spec::simd::simd_align::llvm::universal
 llvm+riscv64      spec::simd::simd_f32x4_rounding::llvm::universal
 llvm+riscv64      spec::simd::simd_f64x2_rounding::llvm::universal
 llvm+riscv64      wasmer::nan_canonicalization::llvm::universal
-llvm+riscv64      wasmer::stack_overflow_sret::llvm::universal
+
+#6032
+llvm+riscv64      wasmer::stack_overflow_sret::llvm
+
 # riscv support on Cranelift is also very young
-cranelift+riscv64 spec::align::cranelift::universal
-cranelift+riscv64 spec::memory_copy::cranelift::universal
-cranelift+riscv64 spec::memory_trap::cranelift::universal
-cranelift+riscv64 spec::r#if::cranelift::universal
+cranelift+riscv64 spec::align::cranelift
+cranelift+riscv64 spec::memory_copy::cranelift
+cranelift+riscv64 spec::memory_trap::cranelift
+cranelift+riscv64 spec::r#if::cranelift
 
 # no SIMD on riscv, Cranelift will not handle them
 cranelift+riscv64 spec::simd
+# 6078
+cranelift+riscv64 wasmer::simd_generated_ext_ops
+cranelift+riscv64 wasmer::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
+
+# #6017 - a crash in the LLVM compiler
+llvm+loongarch64  spec::simd::simd_f32x4::llvm
+llvm+loongarch64  spec::simd::simd_f64x2::llvm
+llvm+loongarch64  spec::simd::simd_load::llvm
+llvm+loongarch64  spec::simd::simd_splat::llvm
+llvm+loongarch64  spec::simd_f32x4::llvm
+llvm+loongarch64  spec::simd_f64x2::llvm
+llvm+loongarch64  spec::simd_load::llvm
+llvm+loongarch64  spec::simd_splat::llvm
+
 
 # Windows doesn't overcommit and fails to allocate 4GB of memory
 windows wasmer::max_size_of_memory
@@ -63,6 +109,9 @@ windows wasmer::max_size_of_memory
 aarch64+linux spec::align
 aarch64+linux spec::memory_trap
 
+# TODO: #5816
+cranelift+riscv64 spec::skip_stack_guard_page
+
 # Frontends
 
 ## WASI
@@ -343,3 +392,11 @@ windows     wasitests::nightly_2022_10_18::host_fs::path_rename
 
 # FIXME - re-enable once the path resolution failures in WasiFs have been worked out
 path_rename
+
+# #5943 - multi-value tests
+singlepass        multi_value_imports
+cranelift         multi_value_imports
+llvm+windows      multi_value_imports
+llvm+loongarch64  multi_value_imports
+llvm+riscv64      multi_value_imports
+llvm+windows      static_function_with_results
diff --git a/tests/integration/cli/Cargo.toml b/tests/integration/cli/Cargo.toml
index a29b9d0a37..faff9b1125 100644
--- a/tests/integration/cli/Cargo.toml
+++ b/tests/integration/cli/Cargo.toml
@@ -1,41 +1,42 @@
 [package]
 name = "wasmer-integration-tests-cli"
-version = "4.3.7"
-authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+version = "7.0.0"
 description = "CLI integration tests"
-repository = "https://github.com/wasmerio/wasmer"
-edition = "2021"
+authors.workspace = true
+repository.workspace = true
+edition.workspace = true
 publish = false
 
 [dev-dependencies]
-rand = "0.8.5"
-target-lexicon = "0.12.4"
-serde = { version = "1.0.147", features = ["derive"] }
-insta = { version = "1.21.1", features = ["json"] }
-md5 = "0.7.0"
-hex = "0.4.3"
-pretty_assertions = "1.3.0"
-object = "0.30.0"
+rand.workspace = true
+target-lexicon.workspace = true
+serde.workspace = true
+insta = { workspace = true, features = ["json"] }
+md5.workspace = true
+hex.workspace = true
+pretty_assertions.workspace = true
+object.workspace = true
 reqwest = { workspace = true, default-features = false, features = ["json", "blocking", "rustls-tls"] }
-tokio = { version = "1", features = [ "rt", "rt-multi-thread", "macros" ] }
-assert_cmd = "2.0.8"
-predicates = "2.1.5"
-once_cell = "1.17.1"
-futures = "0.3.28"
-regex = "1.8.3"
+tokio = { workspace = true, features = [ "rt", "rt-multi-thread", "macros", "process" ] }
+assert_cmd.workspace = true
+predicates.workspace = true
+once_cell.workspace = true
+futures.workspace = true
+regex.workspace = true
 libc.workspace = true
 
 [dependencies]
-anyhow = "1"
-tempfile = "3.6.0"
-target-lexicon = "0.12.5"
-tar = "0.4.38"
-flate2 = "1.0.24"
-dirs = "4.0.0"
-derivative = { version = "^2" }
-wasmer-registry = { path = "../../../lib/registry", default-features = false }
+anyhow.workspace = true
+tempfile.workspace = true
+target-lexicon.workspace = true
+tar.workspace = true
+flate2.workspace = true
+dirs.workspace = true
 
 [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..250337cc02 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
 }
@@ -128,14 +153,14 @@ fn c_flags() {
         .output()
         .unwrap();
 
-    let pkg_config = vec![
+    let pkg_config = [
         format!("prefix={}", wasmer_dir.display()),
         format!("exec_prefix={}", wasmer_dir.join("bin").display()),
         format!("includedir={}", wasmer_dir.join("include").display()),
         format!("libdir={}", wasmer_dir.join("lib").display()),
-        format!(""),
-        format!("Name: wasmer"),
-        format!("Description: The Wasmer library for running WebAssembly"),
+        String::new(),
+        "Name: wasmer".to_string(),
+        "Description: The Wasmer library for running WebAssembly".to_string(),
         format!("Version: {}", env!("CARGO_PKG_VERSION")),
         format!("Cflags: -I{}", wasmer_dir.join("include").display()),
         format!("Libs: -L{} -lwasmer", wasmer_dir.join("lib").display()),
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..af9104d1df 100644
--- a/tests/integration/cli/tests/create_exe.rs
+++ b/tests/integration/cli/tests/create_exe.rs
@@ -7,7 +7,7 @@ use std::{
     process::Command,
 };
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use assert_cmd::prelude::OutputAssertExt;
 use tempfile::TempDir;
 use wasmer_integration_tests_cli::*;
@@ -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}");
 
@@ -170,11 +170,19 @@ fn test_create_exe_with_pirita_works_1() {
 
     let stderr = String::from_utf8_lossy(&cmd.stderr);
 
-    assert_eq!(stderr.lines().map(|s| s.trim().to_string()).collect::<Vec<_>>(), vec![
-        format!("error: cannot compile more than one atom at a time"),
-        format!("│   1: note: use --atom <ATOM> to specify which atom to compile"),
-        format!("╰─▶ 2: where <ATOM> is one of: wabt, wasm-interp, wasm-strip, wasm-validate, wasm2wat, wast2json, wat2wasm"),
-    ]);
+    assert_eq!(
+        stderr
+            .lines()
+            .map(|s| s.trim().to_string())
+            .collect::<Vec<_>>(),
+        vec![
+            format!("error: cannot compile more than one atom at a time"),
+            format!("│   1: note: use --atom <ATOM> to specify which atom to compile"),
+            format!(
+                "╰─▶ 2: where <ATOM> is one of: wabt, wasm-interp, wasm-strip, wasm-validate, wasm2wat, wast2json, wat2wasm"
+            ),
+        ]
+    );
 
     assert!(!cmd.status.success());
 
@@ -265,9 +273,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 +306,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 +406,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,14 +554,14 @@ 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`
+    // test with `--volume`
     let result = run_code(
         &operating_dir,
         &executable_path,
         &[
-            "--mapdir=abc:.".to_string(),
+            "--volume=.:abc".to_string(),
             "--script".to_string(),
             "abc/test.js".to_string(),
         ],
@@ -559,7 +569,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 +683,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 +838,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/fixtures/init2.toml b/tests/integration/cli/tests/fixtures/init2.toml
index 52310b228f..50f8291746 100644
--- a/tests/integration/cli/tests/fixtures/init2.toml
+++ b/tests/integration/cli/tests/fixtures/init2.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
\ No newline at end of file
diff --git a/tests/integration/cli/tests/gen_c_header.rs b/tests/integration/cli/tests/gen_c_header.rs
index ee1a5a67aa..e09df5d8d2 100644
--- a/tests/integration/cli/tests/gen_c_header.rs
+++ b/tests/integration/cli/tests/gen_c_header.rs
@@ -19,7 +19,12 @@ fn gen_c_header_works() -> anyhow::Result<()> {
         .unwrap();
 
     let file = std::fs::read_to_string(&out_path).expect("no header.h file");
-    assert!(file.contains("wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0"), "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file");
+    assert!(
+        file.contains(
+            "wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0"
+        ),
+        "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file"
+    );
 
     let _ = Command::new(get_wasmer_path())
         .arg("gen-c-header")
@@ -59,7 +64,12 @@ fn gen_c_header_works_pirita() -> anyhow::Result<()> {
         .unwrap();
 
     let file = std::fs::read_to_string(&out_path).expect("no header.h file");
-    assert!(file.contains("wasmer_function_0f41d38dcfb5abc1fadb5e9acbc5c645e53fe4d0dd86270b72a09bfeee04d055_0"), "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file");
+    assert!(
+        file.contains(
+            "wasmer_function_0f41d38dcfb5abc1fadb5e9acbc5c645e53fe4d0dd86270b72a09bfeee04d055_0"
+        ),
+        "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file"
+    );
 
     let cmd = Command::new(get_wasmer_path())
         .arg("gen-c-header")
diff --git a/tests/integration/cli/tests/msrv.rs b/tests/integration/cli/tests/msrv.rs
index 8beac17371..62b50fe550 100644
--- a/tests/integration/cli/tests/msrv.rs
+++ b/tests/integration/cli/tests/msrv.rs
@@ -46,22 +46,6 @@ fn rust_toolchain_file_is_up_to_date() {
     ensure_file_contents(rust_toolchain, expected);
 }
 
-#[test]
-fn ci_files_are_up_to_date() {
-    let pattern = Regex::new(r#"MSRV:\s*"\d+\.\d+""#).unwrap();
-    let replacement = format!("MSRV: \"{}\"", MSRV.as_str());
-    let workflows = project_root().join(".github").join("workflows");
-
-    for result in workflows.read_dir().unwrap() {
-        let path = result.unwrap().path();
-
-        let contents = std::fs::read_to_string(&path).unwrap();
-        let expected = pattern.replace_all(&contents, &replacement);
-
-        ensure_file_contents(path, expected);
-    }
-}
-
 /// Get the root directory for this repository.
 fn project_root() -> &'static Path {
     Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -78,11 +62,11 @@ fn ensure_file_contents(path: impl AsRef<Path>, contents: impl AsRef<str>) {
     let path = path.as_ref();
     let contents = contents.as_ref();
 
-    if let Ok(old_contents) = std::fs::read_to_string(path) {
-        if contents == old_contents {
-            // File is already up to date
-            return;
-        }
+    if let Ok(old_contents) = std::fs::read_to_string(path)
+        && contents == old_contents
+    {
+        // File is already up to date
+        return;
     }
 
     let display_path = path.strip_prefix(project_root()).unwrap_or(path);
@@ -96,7 +80,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..4c29d1f785 100644
--- a/tests/integration/cli/tests/packages/axum/Cargo.toml
+++ b/tests/integration/cli/tests/packages/axum/Cargo.toml
@@ -1,17 +1,17 @@
 [package]
 name = "wasix-axum"
 version = "0.1.0"
-edition = "2021"
+edition.workspace = true
 
 [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"] }
+axum = { workspace = true, features = ["tokio", "json"] }
+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"] }
-parking_lot = { version = "=0.12.1", features = ["nightly"] }
+tokio = { workspace = true, default-features = false, features = ["full"] }
+parking_lot = { workspace = true, features = ["nightly"] }
 
 [patch.crates-io]
 tokio = { git = "https://github.com/wasix-org/tokio.git", branch = "wasix-1.24.2" }
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..fe253066cd 100644
--- a/tests/integration/cli/tests/run.rs
+++ b/tests/integration/cli/tests/run.rs
@@ -9,9 +9,9 @@ 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 reqwest::{IntoUrl, blocking::Client};
 use tempfile::TempDir;
 use wasmer_integration_tests_cli::{
     asset_path,
@@ -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 = "/:
 .
@@ -132,14 +181,19 @@ fn run_python_create_temp_dir_in_subprocess() {
     let output = Command::new(get_wasmer_path())
         .arg("run")
         .arg("python/python")
-        .arg("--mapdir")
-        .arg(format!("/code:{}", resources.display()))
+        .arg("--volume")
+        .arg(format!("{}:/code", resources.display()))
         .arg("--")
         .arg("/code/main.py")
         .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]
@@ -150,16 +204,21 @@ fn run_php_with_sqlite() {
         .arg("-q")
         .arg("run")
         .arg(php_wasm)
-        .arg("--mapdir")
-        .arg(format!("/db:{}", db.display()))
-        .arg("--mapdir")
-        .arg(format!("/app:{}", app_dir.display()))
+        .arg("--volume")
+        .arg(format!("{}:/db", db.display()))
+        .arg("--volume")
+        .arg(format!("{}:/app", app_dir.display()))
         .arg("--")
         .arg("/app/test.php")
         .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,52 +350,73 @@ 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(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("https://wasmer.io/python/python@0.2.0")
+        .arg(format!("--volume={}:.", 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(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("https://wasmer.io/python/python@0.2.0")
+        .arg(format!("--volume={}:.", 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(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("python/python@0.2.0")
+        .arg(format!("--volume={}:.", 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())
         .arg("run")
         .arg("_/python")
-        .arg(format!("--mapdir=.:{}", asset_path().display()))
+        .arg(format!("--volume={}:.", 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"));
+    }
 }
 
 #[test]
@@ -378,7 +453,7 @@ fn run_test_caching_works_for_packages() {
 
     let assert = Command::new(get_wasmer_path())
         .arg("python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("--registry=wasmer.io")
         .arg("/app/test.py")
         .env("WASMER_CACHE_DIR", wasmer_dir.path())
@@ -393,7 +468,7 @@ fn run_test_caching_works_for_packages() {
 
     let assert = Command::new(get_wasmer_path())
         .arg("python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("--registry=wasmer.io")
         .arg("/app/test.py")
         .env("WASMER_CACHE_DIR", wasmer_dir.path())
@@ -413,7 +488,7 @@ fn run_test_caching_works_for_packages_with_versions() {
 
     let assert = Command::new(get_wasmer_path())
         .arg("python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("--registry=wasmer.io")
         .arg("/app/test.py")
         .env("RUST_LOG", &*CACHE_RUST_LOG)
@@ -429,7 +504,7 @@ fn run_test_caching_works_for_packages_with_versions() {
 
     let assert = Command::new(get_wasmer_path())
         .arg("python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("--registry=wasmer.io")
         .arg("/app/test.py")
         .env("RUST_LOG", &*CACHE_RUST_LOG)
@@ -450,7 +525,7 @@ fn run_test_caching_works_for_urls() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg("https://wasmer.io/python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("/app/test.py")
         .env("RUST_LOG", &*CACHE_RUST_LOG)
         .env("WASMER_CACHE_DIR", wasmer_dir.path())
@@ -465,7 +540,7 @@ fn run_test_caching_works_for_urls() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg("https://wasmer.io/python/python@0.1.0")
-        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg(format!("--volume={}:/app", asset_path().display()))
         .arg("/app/test.py")
         .env("RUST_LOG", &*CACHE_RUST_LOG)
         .env("WASMER_CACHE_DIR", wasmer_dir.path())
@@ -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!"));
 }
@@ -590,7 +663,7 @@ fn wasi_runner_on_disk_mount_using_relative_directory_on_the_host() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg(fixtures::python())
-        .arg("--mapdir=/app:.")
+        .arg("--volume=.:/app")
         .arg("--")
         .arg("/app/main.py")
         .env("RUST_LOG", &*RUST_LOG)
@@ -612,7 +685,7 @@ fn wasi_runner_on_disk_with_mounted_directories() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg(fixtures::qjs())
-        .arg(format!("--mapdir=/app:{}", temp.path().display()))
+        .arg(format!("--volume={}:/app", temp.path().display()))
         .arg("--")
         .arg("/app/index.js")
         .env("RUST_LOG", &*RUST_LOG)
@@ -633,7 +706,7 @@ fn wasi_runner_on_disk_with_mounted_directories_and_webc_volumes() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg(fixtures::python())
-        .arg(format!("--mapdir=/app:{}", temp.path().display()))
+        .arg(format!("--volume={}:/app", temp.path().display()))
         .arg("--")
         .arg("-B")
         .arg("/app/main.py")
@@ -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());
@@ -762,7 +836,7 @@ fn wcgi_runner_on_disk_with_mounted_directories() {
     let mut cmd = Command::new(get_wasmer_path());
     cmd.arg("run")
         .arg(format!("--addr=127.0.0.1:{port}"))
-        .arg(format!("--mapdir=/path/to:{}", temp.path().display()))
+        .arg(format!("--volume={}:/path/to", temp.path().display()))
         .arg(fixtures::static_server())
         .env("RUST_LOG", &*RUST_LOG);
 
@@ -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();
@@ -796,7 +871,7 @@ fn issue_3794_unable_to_mount_relative_paths() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
         .arg(fixtures::coreutils())
-        .arg(format!("--mapdir=./some-dir/:{}", temp.path().display()))
+        .arg(format!("--volume={}:./some-dir/", temp.path().display()))
         .arg("--command-name=cat")
         .arg("--")
         .arg("./some-dir/message.txt")
@@ -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");
@@ -972,6 +1055,7 @@ fn run_quickjs_via_url() {
 }
 
 #[test]
+#[allow(unused_attributes)]
 #[cfg_attr(
     all(target_env = "musl", target_os = "linux"),
     ignore = "wasmer run-unstable segfaults on musl"
@@ -980,6 +1064,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 +1086,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 +1116,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 +1249,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(_) => {
@@ -1167,7 +1260,7 @@ fn read_line(reader: &mut dyn Read) -> Result<String, std::io::Error> {
         }
     }
 
-    let line = String::from_utf8(line).map_err(|e| std::io::Error::new(ErrorKind::Other, e))?;
+    let line = String::from_utf8(line).map_err(std::io::Error::other)?;
     Ok(line)
 }
 
@@ -1224,5 +1317,5 @@ fn http_get(url: impl IntoUrl) -> Result<String, reqwest::Error> {
 }
 
 fn random_port() -> u16 {
-    rand::thread_rng().gen_range(10_000_u16..u16::MAX)
+    rand::rng().random_range(10_000_u16..u16::MAX)
 }
diff --git a/tests/integration/cli/tests/snapshot.rs b/tests/integration/cli/tests/snapshot.rs
index a75274eddc..5ecdefbb17 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)
     }
@@ -228,10 +243,10 @@ impl TestBuilder {
         let mut snapshot = build_snapshot(self.spec, code);
         // TODO: figure out why snapshot exit code is 79 on macos
         #[cfg(target_os = "macos")]
-        if let TestResult::Success(ref mut output) = snapshot.result {
-            if output.exit_code == 79 {
-                output.exit_code = 78;
-            }
+        if let TestResult::Success(ref mut output) = snapshot.result
+            && output.exit_code == 79
+        {
+            output.exit_code = 78;
         }
         snapshot
     }
@@ -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("--volume").arg(format!(
+            "{}:{}",
+            mount.1.to_str().unwrap(),
+            mount.0.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..04c0a015c2 100644
--- a/tests/integration/ios/Cargo.toml
+++ b/tests/integration/ios/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "wasmer-integration-tests-ios"
-version = "4.3.7"
-authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 description = "iOS integration tests"
-repository = "https://github.com/wasmerio/wasmer"
-edition = "2018"
+version.workspace = true
+authors.workspace = true
+repository.workspace = true
+edition.workspace = true
 publish = false
 
 [features]
 default = ["webc_runner"]
-webc_runner = []
\ No newline at end of file
+webc_runner = []
diff --git a/tests/lib/compiler-test-derive/Cargo.toml b/tests/lib/compiler-test-derive/Cargo.toml
index e4036c5d1a..b14b4cd69b 100644
--- a/tests/lib/compiler-test-derive/Cargo.toml
+++ b/tests/lib/compiler-test-derive/Cargo.toml
@@ -4,21 +4,21 @@ proc-macro = true
 [package]
 name = "compiler-test-derive"
 version = "0.0.1"
-authors = ["Wasmer Engineering <engineering@wasmer.io>"]
-edition = "2018"
-license = "MIT"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
 
 description = "A macro to generate easily tests across compilers and engines"
 keywords = ["unsafe", "body", "fn", "safety", "hygiene"]
 categories = ["rust-patterns", ]
 
 [dependencies]
-proc-macro2 = "1.*"
-quote = "1.*"
-syn =  { version = "1.*", features = ["full"] }
+proc-macro2.workspace = true
+quote.workspace = true
+syn = { workspace = true, features = ["full"] }
 
 [features]
 
 [dev-dependencies]
-pretty_assertions = "1.0"
-trybuild = "1.0.11"
+pretty_assertions.workspace = true
+trybuild.workspace = true
diff --git a/tests/lib/compiler-test-derive/build.rs b/tests/lib/compiler-test-derive/build.rs
index d65caeba6a..5eb2d3685a 100644
--- a/tests/lib/compiler-test-derive/build.rs
+++ b/tests/lib/compiler-test-derive/build.rs
@@ -1,12 +1,17 @@
 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);
-    }
-    if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ARCH") {
-        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_OS={}",
+        std::env::var("CARGO_CFG_TARGET_OS")
+            .expect("CARGO_CFG_TARGET_OS must be provided by cargo")
+    );
+    println!(
+        "cargo:rustc-env=CFG_TARGET_ARCH={}",
+        std::env::var("CARGO_CFG_TARGET_ARCH")
+            .expect("CARGO_CFG_TARGET_ARCH must be provided by cargo")
+    );
+    println!(
+        "cargo:rustc-env=CFG_TARGET_ENV={}",
+        std::env::var("CARGO_CFG_TARGET_ENV")
+            .expect("CARGO_CFG_TARGET_ENV must be provided by cargo")
+    );
 }
diff --git a/tests/lib/compiler-test-derive/src/ignores.rs b/tests/lib/compiler-test-derive/src/ignores.rs
index 12364cf219..1eef3e7179 100644
--- a/tests/lib/compiler-test-derive/src/ignores.rs
+++ b/tests/lib/compiler-test-derive/src/ignores.rs
@@ -1,11 +1,9 @@
+use std::env;
 use std::fs::File;
 use std::path::PathBuf;
 
 use std::io::{BufRead, BufReader};
-
-pub const CFG_TARGET_OS: &str = env!("CFG_TARGET_OS");
-pub const CFG_TARGET_ARCH: &str = env!("CFG_TARGET_ARCH");
-pub const CFG_TARGET_ENV: &str = env!("CFG_TARGET_ENV");
+use std::sync::OnceLock;
 
 #[derive(Debug, Clone)]
 struct IgnorePattern {
@@ -27,14 +25,11 @@ impl IgnorePattern {
         compiler: &str,
         canonical_path: &str,
     ) -> bool {
-        self.os.as_ref().map_or(true, |val| val == os)
-            && self.arch.as_ref().map_or(true, |val| val == arch)
-            && self
-                .target_env
-                .as_ref()
-                .map_or(true, |val| val == target_env)
-            && self.engine.as_ref().map_or(true, |val| val == engine)
-            && self.compiler.as_ref().map_or(true, |val| val == compiler)
+        self.os.as_ref().is_none_or(|val| val == os)
+            && self.arch.as_ref().is_none_or(|val| val == arch)
+            && self.target_env.as_ref().is_none_or(|val| val == target_env)
+            && self.engine.as_ref().is_none_or(|val| val == engine)
+            && self.compiler.as_ref().is_none_or(|val| val == compiler)
             && (self.pattern_to_ignore == "*" || canonical_path.contains(&*self.pattern_to_ignore))
     }
 }
@@ -63,10 +58,29 @@ impl Ignores {
     }
 
     pub fn should_ignore_host(&self, engine: &str, compiler: &str, canonical_path: &str) -> bool {
+        static CFG_TARGET_OS: OnceLock<String> = OnceLock::new();
+        let target_os = CFG_TARGET_OS.get_or_init(|| {
+            env::var("CFG_TARGET_OS")
+                .expect("CFG_TARGET_OS variable expected from build.rs")
+                .to_string()
+        });
+        static CFG_TARGET_ARCH: OnceLock<String> = OnceLock::new();
+        let target_arch = CFG_TARGET_ARCH.get_or_init(|| {
+            env::var("CFG_TARGET_ARCH")
+                .expect("CFG_TARGET_ARCH variable expected from build.rs")
+                .to_string()
+        });
+        static CFG_TARGET_ENV: OnceLock<String> = OnceLock::new();
+        let target_env = CFG_TARGET_ENV.get_or_init(|| {
+            env::var("CFG_TARGET_ENV")
+                .expect("CFG_TARGET_ENV variable expected from build.rs")
+                .to_string()
+        });
+
         self.should_ignore(
-            CFG_TARGET_OS,
-            CFG_TARGET_ARCH,
-            CFG_TARGET_ENV,
+            target_os,
+            target_arch,
+            target_env,
             engine,
             compiler,
             canonical_path,
@@ -111,7 +125,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
@@ -123,7 +137,11 @@ impl Ignores {
                             compiler = Some(alias.to_string());
                         }
                         other => {
-                            panic!("Alias {:?} not currently supported (defined in ignores.txt in line {})", other, i+1);
+                            panic!(
+                                "Alias {:?} not currently supported (defined in ignores.txt in line {})",
+                                other,
+                                i + 1
+                            );
                         }
                     }
                 }
@@ -160,70 +178,78 @@ mod tests {
 
     #[test]
     fn features_match() -> Result<(), ()> {
-        assert!(IgnorePattern {
-            os: None,
-            arch: None,
-            target_env: None,
-            engine: None,
-            compiler: None,
-            pattern_to_ignore: "*".to_string()
-        }
-        .should_ignore(
-            "unknown",
-            "unknown",
-            "",
-            "engine",
-            "compiler",
-            "some::random::text"
-        ));
-        assert!(IgnorePattern {
-            os: None,
-            arch: None,
-            target_env: None,
-            engine: None,
-            compiler: None,
-            pattern_to_ignore: "some::random".to_string()
-        }
-        .should_ignore(
-            "unknown",
-            "unknown",
-            "",
-            "engine",
-            "compiler",
-            "some::random::text"
-        ));
-        assert!(!IgnorePattern {
-            os: Some("macos".to_string()),
-            arch: None,
-            target_env: None,
-            engine: None,
-            compiler: None,
-            pattern_to_ignore: "other".to_string()
-        }
-        .should_ignore(
-            "unknown",
-            "unknown",
-            "",
-            "engine",
-            "compiler",
-            "some::random::text"
-        ));
-        assert!(!IgnorePattern {
-            os: Some("macos".to_string()),
-            arch: None,
-            target_env: None,
-            engine: Some("universal".to_string()),
-            compiler: None,
-            pattern_to_ignore: "other".to_string()
-        }
-        .should_ignore(
-            "macos",
-            "unknown",
-            "",
-            "universal",
-            "compiler",
-            "some::random::text"
-        ));
+        assert!(
+            IgnorePattern {
+                os: None,
+                arch: None,
+                target_env: None,
+                engine: None,
+                compiler: None,
+                pattern_to_ignore: "*".to_string()
+            }
+            .should_ignore(
+                "unknown",
+                "unknown",
+                "",
+                "engine",
+                "compiler",
+                "some::random::text"
+            )
+        );
+        assert!(
+            IgnorePattern {
+                os: None,
+                arch: None,
+                target_env: None,
+                engine: None,
+                compiler: None,
+                pattern_to_ignore: "some::random".to_string()
+            }
+            .should_ignore(
+                "unknown",
+                "unknown",
+                "",
+                "engine",
+                "compiler",
+                "some::random::text"
+            )
+        );
+        assert!(
+            !IgnorePattern {
+                os: Some("macos".to_string()),
+                arch: None,
+                target_env: None,
+                engine: None,
+                compiler: None,
+                pattern_to_ignore: "other".to_string()
+            }
+            .should_ignore(
+                "unknown",
+                "unknown",
+                "",
+                "engine",
+                "compiler",
+                "some::random::text"
+            )
+        );
+        assert!(
+            !IgnorePattern {
+                os: Some("macos".to_string()),
+                arch: None,
+                target_env: None,
+                engine: Some("universal".to_string()),
+                compiler: None,
+                pattern_to_ignore: "other".to_string()
+            }
+            .should_ignore(
+                "macos",
+                "unknown",
+                "",
+                "universal",
+                "compiler",
+                "some::random::text"
+            )
+        );
         Ok(())
     }
 }
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/Cargo.toml b/tests/lib/test-generator/Cargo.toml
index 0374ef83ce..5c3701471e 100644
--- a/tests/lib/test-generator/Cargo.toml
+++ b/tests/lib/test-generator/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
 name = "test-generator"
 version = "0.1.0"
-edition = "2018"
+edition.workspace = true
 publish = false
 license = "Apache-2.0 WITH LLVM-exception"
 
 [dependencies]
-anyhow = "1.0"
-target-lexicon = "0.12"
+anyhow.workspace = true
+target-lexicon.workspace = true
 
 [features]
 test-universal = []
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..a228737fbe 100644
--- a/tests/lib/test-generator/src/processors.rs
+++ b/tests/lib/test-generator/src/processors.rs
@@ -1,5 +1,5 @@
 //! Here we define the processors usable for each test genrator
-use crate::{extract_name, Test, Testsuite};
+use crate::{Test, Testsuite, extract_name};
 use std::path::PathBuf;
 
 /// Given a Testsuite and a path, process the path in case is a wast
@@ -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..d896e53727 100644
--- a/tests/lib/wast/Cargo.toml
+++ b/tests/lib/wast/Cargo.toml
@@ -1,31 +1,32 @@
 [package]
 name = "wasmer-wast"
-version = "4.3.7"
-authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 description = "wast testing support for wasmer"
+version.workspace = true
+authors.workspace = true
 license = "MIT OR Apache-2.0 WITH LLVM-exception"
 categories = ["wasm"]
 keywords = ["wasm", "webassembly"]
 repository = "https://github.com/wasmerio/wasmer"
 readme = "README.md"
-edition = "2018"
+edition.workspace = true
 
 [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 = "=7.0.0" }
+wasmer-wasix = { path = "../../../lib/wasix", version = "=0.700.0" }
+wasmer = { path = "../../../lib/api", version = "=7.0.0", default-features = false }
+virtual-fs = { path = "../../../lib/virtual-fs", version = "0.700.0" }
 
-anyhow = "1.0"
-wast = "38.0"
-serde = "1"
-tempfile = "3.6.0"
-thiserror = "1.0"
-futures = "0.3"
-tokio = { version = "1", features = [
-    "io-util",
-    "rt",
+anyhow.workspace = true
+wast.workspace = true
+serde.workspace = true
+tempfile.workspace = true
+thiserror.workspace = true
+futures.workspace = true
+tokio = { workspace = true, features = [
+	"io-util",
+	"rt",
 ], default-features = false }
+fs_extra.workspace = true
 
 [features]
 default = ["wat"]
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..33fe703da1 100644
--- a/tests/lib/wast/src/wasi_wast.rs
+++ b/tests/lib/wast/src/wasi_wast.rs
@@ -1,25 +1,28 @@
 use std::{
-    fs::{read_dir, File, OpenOptions, ReadDir},
+    fs::{self, File, OpenOptions, ReadDir, read_dir},
     future::Future,
     io::{self, Read, SeekFrom},
     path::{Path, PathBuf},
     pin::Pin,
-    sync::{mpsc, Arc, Mutex},
+    sync::{Arc, Mutex, mpsc},
     task::{Context, Poll},
 };
 
+use anyhow::{Context as _, anyhow};
+use fs_extra::dir::{self, copy};
+use tempfile::TempDir;
 use tokio::runtime::Handle;
 use virtual_fs::{
-    host_fs, mem_fs, passthru_fs, tmp_fs, union_fs, AsyncRead, AsyncSeek, AsyncWrite,
-    AsyncWriteExt, FileSystem, Pipe, ReadBuf, RootFileSystemBuilder,
+    AsyncRead, AsyncSeek, AsyncWrite, AsyncWriteExt, FileSystem, Pipe, ReadBuf,
+    RootFileSystemBuilder, host_fs, mem_fs, passthru_fs, tmp_fs, union_fs,
 };
 use wasmer::{FunctionEnv, Imports, Module, Store};
 use wasmer_types::ModuleHash;
-use wasmer_wasix::runtime::task_manager::{tokio::TokioTaskManager, InlineWaker};
+use wasmer_wasix::runtime::task_manager::{block_on, tokio::TokioTaskManager};
 use wasmer_wasix::types::wasi::{Filesize, Timestamp};
 use wasmer_wasix::{
-    generate_import_object_from_env, get_wasi_version, FsError, PluggableRuntime, VirtualFile,
-    WasiEnv, WasiEnvBuilder, WasiVersion,
+    FsError, PluggableRuntime, VirtualFile, WasiEnv, WasiEnvBuilder, WasiVersion,
+    generate_import_object_from_env, get_wasi_version,
 };
 use wast::parser::{self, Parse, ParseBuffer, Parser};
 
@@ -61,6 +64,7 @@ pub struct WasiTest<'a> {
 }
 
 // TODO: add `test_fs` here to sandbox better
+const TEMP_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tmp/");
 const BASE_TEST_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../wasi-wast/wasi/");
 
 fn get_stdio_output(rx: &mpsc::Receiver<Vec<u8>>) -> anyhow::Result<String> {
@@ -110,7 +114,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);
@@ -120,11 +124,11 @@ impl<'a> WasiTest<'a> {
             wasm_module.read_to_end(&mut out)?;
             out
         };
-        let module_hash = ModuleHash::xxhash(&wasm_bytes);
+        let module_hash = ModuleHash::new(&wasm_bytes);
 
         let module = Module::new(store, wasm_bytes)?;
         let (builder, _tempdirs, mut stdin_tx, stdout_rx, stderr_rx) =
-            { InlineWaker::block_on(async { self.create_wasi_env(filesystem_kind).await }) }?;
+            { block_on(async { self.create_wasi_env(filesystem_kind).await }) }?;
 
         let (instance, _wasi_env) =
             builder
@@ -137,7 +141,7 @@ impl<'a> WasiTest<'a> {
             // let mut wasi_stdin = { wasi_env.data(store).stdin().unwrap().unwrap() };
             // Then we can write to it!
             let data = stdin.stream.to_string();
-            InlineWaker::block_on(async move {
+            block_on(async move {
                 stdin_tx.write_all(data.as_bytes()).await?;
                 stdin_tx.shutdown().await?;
 
@@ -155,9 +159,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 +167,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);
         }
 
@@ -202,41 +204,54 @@ impl<'a> WasiTest<'a> {
 
         match filesystem_kind {
             WasiFileSystemKind::Host => {
-                let fs = host_fs::FileSystem::new(Handle::current(), PathBuf::from(BASE_TEST_DIR))
-                    .unwrap();
+                // Use a temporary folder, otherwise other file systems will spot the artifacts of this FS.
+                let mut source = PathBuf::from(BASE_TEST_DIR);
+                source.push("test_fs");
+
+                fs::create_dir_all(TEMP_ROOT)
+                    .with_context(|| anyhow!("cannot create root tmp folder for WASI tests"))?;
+
+                let root_dir = TempDir::with_prefix_in("host_fs_copy-", TEMP_ROOT)
+                    .with_context(|| anyhow!("cannot create temporary directory"))?;
+                copy(source.as_path(), root_dir.path(), &dir::CopyOptions::new())
+                    .with_context(|| anyhow!("cannot copy to the temporary directory"))?;
+                let base_dir = root_dir.path().to_path_buf();
+                host_temp_dirs_to_not_drop.push(root_dir);
+
+                let fs = host_fs::FileSystem::new(Handle::current(), base_dir.clone()).unwrap();
 
                 for (alias, real_dir) in &self.mapped_dirs {
-                    let mut dir = PathBuf::from(BASE_TEST_DIR);
+                    let mut dir = base_dir.clone();
                     dir.push(real_dir);
                     builder.add_map_dir(alias, dir)?;
                 }
 
                 // due to the structure of our code, all preopen dirs must be mapped now
                 for dir in &self.dirs {
-                    let mut new_dir = PathBuf::from(BASE_TEST_DIR);
+                    let mut new_dir = base_dir.clone();
                     new_dir.push(dir);
                     builder.add_map_dir(dir, new_dir)?;
                 }
 
                 for alias in &self.temp_dirs {
-                    let temp_dir = tempfile::tempdir_in(PathBuf::from(BASE_TEST_DIR))?;
+                    let temp_dir = tempfile::tempdir_in(&base_dir)?;
                     builder.add_map_dir(alias, temp_dir.path())?;
                     host_temp_dirs_to_not_drop.push(temp_dir);
                 }
 
-                builder.set_fs(Box::new(fs));
+                builder.set_fs(Arc::new(fs) as Arc<dyn FileSystem + Send + Sync>);
             }
 
             other => {
-                let fs: Box<dyn FileSystem + Send + Sync> = match other {
-                    WasiFileSystemKind::InMemory => Box::<mem_fs::FileSystem>::default(),
-                    WasiFileSystemKind::Tmp => Box::<tmp_fs::TmpFileSystem>::default(),
+                let fs: Arc<dyn FileSystem + Send + Sync> = match other {
+                    WasiFileSystemKind::InMemory => Arc::<mem_fs::FileSystem>::default(),
+                    WasiFileSystemKind::Tmp => Arc::<tmp_fs::TmpFileSystem>::default(),
                     WasiFileSystemKind::PassthruMemory => {
-                        let fs = Box::<mem_fs::FileSystem>::default();
-                        Box::new(passthru_fs::PassthruFileSystem::new(fs))
+                        let fs = Arc::<mem_fs::FileSystem>::default();
+                        Arc::new(passthru_fs::PassthruFileSystem::new_arc(fs))
                     }
                     WasiFileSystemKind::RootFileSystemBuilder => {
-                        Box::new(RootFileSystemBuilder::new().build())
+                        Arc::new(RootFileSystemBuilder::new().build())
                     }
                     WasiFileSystemKind::UnionHostMemory => {
                         let a = mem_fs::FileSystem::default();
@@ -279,10 +294,10 @@ impl<'a> WasiTest<'a> {
                             Box::new(f),
                         )?;
 
-                        Box::new(union)
+                        Arc::new(union)
                     }
                     _ => {
-                        panic!("unexpected filesystem type {:?}", other);
+                        panic!("unexpected filesystem type {other:?}");
                     }
                 };
 
@@ -307,7 +322,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 +393,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 +473,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 +495,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 +513,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 +531,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 +552,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);
         }
@@ -688,16 +703,10 @@ impl VirtualFile for OutputCapturerer {
 
 impl AsyncSeek for OutputCapturerer {
     fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
-        Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not seek logging wrapper",
-        ))
+        Err(io::Error::other("can not seek logging wrapper"))
     }
     fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not seek logging wrapper",
-        )))
+        Poll::Ready(Err(io::Error::other("can not seek logging wrapper")))
     }
 }
 
@@ -728,10 +737,7 @@ impl AsyncRead for OutputCapturerer {
         _cx: &mut Context<'_>,
         _buf: &mut ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        Poll::Ready(Err(io::Error::new(
-            io::ErrorKind::Other,
-            "can not read from logging wrapper",
-        )))
+        Poll::Ready(Err(io::Error::other("can not read from logging wrapper")))
     }
 }
 
diff --git a/tests/lib/wast/src/wast.rs b/tests/lib/wast/src/wast.rs
index 80b02adc27..5368e89cf8 100644
--- a/tests/lib/wast/src/wast.rs
+++ b/tests/lib/wast/src/wast.rs
@@ -1,10 +1,14 @@
 use crate::error::{DirectiveError, DirectiveErrors};
 use crate::spectest::spectest_importobject;
-use anyhow::{anyhow, bail, Result};
+use anyhow::{Result, anyhow, bail};
 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::{QuoteWat, Wast as WWast, WastArg};
+use wast::{lexer::Lexer, parser};
 
 /// 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);
@@ -80,7 +93,7 @@ impl Wast {
                 .instances
                 .get(name)
                 .cloned()
-                .ok_or_else(|| anyhow!("failed to find instance named `{}`", name)),
+                .ok_or_else(|| anyhow!("failed to find instance named `{name}`")),
             None => self
                 .current
                 .clone()
@@ -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,47 +132,86 @@ 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 {
-                    bail!(
-                        "expected {:?}, got {:?} (v128 bits: {})",
-                        e,
-                        v128_format(*bits, pattern),
-                        bits
-                    );
+
+            if let Value::V128(bits) = v
+                && let wast::WastRet::Core(WastRetCore::V128(pattern)) = e
+            {
+                let formatted = v128_format(*bits, pattern);
+                bail!("expected {e:?}, got {formatted:?} (v128 bits: {bits})");
+            }
+            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);
+                    let f_bits = f.to_bits();
+                    bail!("expected {f:?} ({e:?}), got {v:?} ({f_bits})")
+                } else {
+                    let f_bits = f.to_bits();
+                    bail!("expected {e:?}, got {v:?} ({f_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);
+                    let f_bits = f.to_bits();
+                    bail!("expected {f:?} ({e:?}), got {v:?} ({f_bits})")
+                } else {
+                    let f_bits = f.to_bits();
+                    bail!("expected {e:?}, got {v:?} ({f_bits})")
                 }
+            } else {
+                bail!("expected {e:?}, got {v:?}")
             }
-            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(())
     }
 
     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),
+            Ok(values) => bail!("expected trap, got {values:?}"),
+            Err(t) => format!("{t}"),
         };
         if self.matches_message_assert_trap(expected, &actual) {
             return Ok(());
         }
-        bail!("expected '{}', got '{}'", expected, actual)
+        bail!("expected '{expected}', got '{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,28 +255,20 @@ 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 \"{}\"",
-                        message,
-                        error_message
-                    )
+                    bail!("assert_invalid: expected \"{message}\", got \"{error_message}\"")
                 }
             }
-            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 +276,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,15 +299,19 @@ 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 {}",
-                        message,
-                        error_message
-                    )
+                    bail!("assert_unlinkable: expected {message}, got {error_message}")
                 }
             }
+            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 +327,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 +367,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 +407,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) {
@@ -355,7 +415,7 @@ impl Wast {
                         break;
                     }
                 }
-                bail!("instantiation failed with: {}", e)
+                bail!("instantiation failed with: {e}")
             }
         };
         if let Some(name) = instance_name {
@@ -416,22 +476,25 @@ 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),
+            other => bail!("couldn't convert {other:?} to a runtime value"),
         })
     }
 
@@ -456,6 +519,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,39 +538,50 @@ 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",
-                actual,
-                expected
-            ),
+            _ => bail!("don't know how to compare {actual:?} and {expected:?} yet"),
         })
     }
 }
@@ -517,54 +602,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 +667,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 +677,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/Cargo.lock b/tests/rust-wasi-tests/Cargo.lock
deleted file mode 100644
index 59c7e8f295..0000000000
--- a/tests/rust-wasi-tests/Cargo.lock
+++ /dev/null
@@ -1,16 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "rust-wasi-tests"
-version = "0.1.0"
-dependencies = [
- "wasi",
-]
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
diff --git a/tests/rust-wasi-tests/Cargo.toml b/tests/rust-wasi-tests/Cargo.toml
index 45731f7731..1a9bf57441 100644
--- a/tests/rust-wasi-tests/Cargo.toml
+++ b/tests/rust-wasi-tests/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "rust-wasi-tests"
 version = "0.1.0"
-edition = "2021"
+edition.workspace = true
 
 [workspace]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-wasi = "0.11.0"
+wasi.workspace = true
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/ported_fd_read.rs b/tests/wasi-fyi/ported_fd_read.rs
index 17394d75aa..bbec8382ed 100644
--- a/tests/wasi-fyi/ported_fd_read.rs
+++ b/tests/wasi-fyi/ported_fd_read.rs
@@ -76,7 +76,7 @@ fn main() {
 }
 
 #[cfg(target_os = "wasi")]
-#[no_mangle]
+#[unsafe(no_mangle)]
 fn second_entry() -> bool {
     let raw_fd = 5;
     let mut buffer = [0u8; 8];
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-fyi/wasm-test.sh b/tests/wasi-fyi/wasm-test.sh
index 89523c7ef7..0860c8bdf4 100755
--- a/tests/wasi-fyi/wasm-test.sh
+++ b/tests/wasi-fyi/wasm-test.sh
@@ -40,7 +40,7 @@ fi
 
 status=0
 
-"../../target/release/wasmer" --mapdir /hamlet:./test_fs/hamlet --mapdir /fyi:./test_fs/fyi "$input_base.wasm" $dir $env -- $arg \
+"../../target/release/wasmer" --volume ./test_fs/hamlet:/hamlet --volume ./test_fs/fyi:/fyi "$input_base.wasm" $dir $env -- $arg \
     < "$stdin" \
     > "$stdout_actual" \
     2> "$stderr_actual" \
diff --git a/tests/wasi-wast/Cargo.lock b/tests/wasi-wast/Cargo.lock
deleted file mode 100644
index 793ea750d6..0000000000
--- a/tests/wasi-wast/Cargo.lock
+++ /dev/null
@@ -1,259 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-
-[[package]]
-name = "getrandom"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "glob"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
-
-[[package]]
-name = "gumdrop"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46571f5d540478cf70d2a42dd0d6d8e9f4b9cc7531544b93311e657b86568a0b"
-dependencies = [
- "gumdrop_derive",
-]
-
-[[package]]
-name = "gumdrop_derive"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "915ef07c710d84733522461de2a734d4d62a3fd39a4d4f404c2f385ef8618d05"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
-
-[[package]]
-name = "leb128"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
-
-[[package]]
-name = "libc"
-version = "0.2.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9457b06509d27052635f90d6466700c65095fdf75409b3fbdd903e988b886f49"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
-dependencies = [
- "getrandom",
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.1.56"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "serde"
-version = "1.0.112"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.112"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec2c5d7e739bc07a3e73381a39d61fdb5f671c60c1df26a130690665803d8226"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
-dependencies = [
- "cfg-if",
- "libc",
- "rand",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
-
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
-[[package]]
-name = "wasi-test-generator"
-version = "0.17.0"
-dependencies = [
- "glob",
- "gumdrop",
- "serde",
- "serde_json",
- "tempfile",
- "wast",
-]
-
-[[package]]
-name = "wast"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fb95ce157a8c779ec301ef3e4c0a7caeb6f9f902f813f1f5f7e464367048924"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/tests/wasi-wast/Cargo.toml b/tests/wasi-wast/Cargo.toml
index 9e7c0d20e5..a481db2dc5 100644
--- a/tests/wasi-wast/Cargo.toml
+++ b/tests/wasi-wast/Cargo.toml
@@ -1,16 +1,16 @@
 [package]
 name = "wasi-test-generator"
-version = "4.3.7"
+version.workspace = true
 description = "Tests for our WASI implementation"
-license = "MIT"
-authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
-edition = "2018"
+license.workspace = true
+authors.workspace = true
+edition.workspace = true
 publish = false
 
 [dependencies]
-glob = "0.3"
-gumdrop = "0.8"
-tempfile = "3.6.0"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-wast = "24.0"
+glob.workspace = true
+gumdrop.workspace = true
+tempfile.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+wast.workspace = true
diff --git a/tests/wasi-wast/src/main.rs b/tests/wasi-wast/src/main.rs
index 7197e8ee75..f649131e8b 100644
--- a/tests/wasi-wast/src/main.rs
+++ b/tests/wasi-wast/src/main.rs
@@ -8,9 +8,9 @@ mod wasitests;
 
 pub use crate::set_up_toolchain::install_toolchains;
 pub use crate::wasi_version::{
-    WasiVersion, ALL_WASI_VERSIONS, LATEST_WASI_VERSION, NIGHTLY_VERSION,
+    ALL_WASI_VERSIONS, LATEST_WASI_VERSION, NIGHTLY_VERSION, WasiVersion,
 };
-pub use crate::wasitests::{build, WasiOptions, WasiTest};
+pub use crate::wasitests::{WasiOptions, WasiTest, build};
 
 use gumdrop::Options;
 
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..0a4023bbdc 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.
@@ -252,16 +252,16 @@ pub fn build(wasi_versions: &[WasiVersion], specific_tests: &[&str]) {
             Ok(path) => {
                 let test = path.to_str().unwrap();
                 if !specific_tests.is_empty() {
-                    if let Some(filename) = path.file_stem().and_then(|f| f.to_str()) {
-                        if specific_tests.contains(&filename) {
-                            compile(temp_dir.path(), test, wasi_versions);
-                        }
+                    if let Some(filename) = path.file_stem().and_then(|f| f.to_str())
+                        && specific_tests.contains(&filename)
+                    {
+                        compile(temp_dir.path(), test, wasi_versions);
                     }
                 } else {
                     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" => {
@@ -427,7 +427,10 @@ fn extract_args_from_source_file(source_code: &str) -> Option<WasiOptions> {
                     args.tempdir.push(value.to_string());
                 }
                 "stdin" => {
-                    assert!(args.stdin.is_none(), "Only the first `stdin` directive is used! Please correct this or update this code");
+                    assert!(
+                        args.stdin.is_none(),
+                        "Only the first `stdin` directive is used! Please correct this or update this code"
+                    );
                     let s = value;
                     let s = s.strip_prefix('"').expect("expected leading '\"' in stdin");
                     let s = s
@@ -437,7 +440,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/fd_read.rs b/tests/wasi-wast/wasi/tests/fd_read.rs
index fbdff89781..209e65aa09 100644
--- a/tests/wasi-wast/wasi/tests/fd_read.rs
+++ b/tests/wasi-wast/wasi/tests/fd_read.rs
@@ -76,7 +76,7 @@ fn main() {
 }
 
 #[cfg(target_os = "wasi")]
-#[no_mangle]
+#[unsafe(no_mangle)]
 fn second_entry() -> bool {
     let raw_fd = 5;
     let mut buffer = [0u8; 8];
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/chdir-getcwd/run.sh b/tests/wasix/chdir-getcwd/run.sh
index 3e033fb898..67acc16cf4 100755
--- a/tests/wasix/chdir-getcwd/run.sh
+++ b/tests/wasix/chdir-getcwd/run.sh
@@ -1,3 +1,3 @@
-$WASMER -q run main.wasm > output
+$WASMER_RUN main.wasm > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
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..521d02a740
--- /dev/null
+++ b/tests/wasix/cloexec/run.sh
@@ -0,0 +1,7 @@
+set -e
+
+# step 1: tests involving the flag itself
+$WASMER_RUN main.wasm -- flag_tests
+
+# step 2: tests involving exec
+$WASMER_RUN main.wasm --volume . -- 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..1adb62fa25
--- /dev/null
+++ b/tests/wasix/closing-pre-opened-dirs/run.sh
@@ -0,0 +1,5 @@
+rm output 2>/dev/null
+
+$WASMER_RUN main.wasm --volume . > output
+
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/context-switching/main.c b/tests/wasix/context-switching/main.c
new file mode 100644
index 0000000000..2efe10369d
--- /dev/null
+++ b/tests/wasix/context-switching/main.c
@@ -0,0 +1,354 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <assert.h>
+#include <spawn.h>
+#include <wasix/context.h>
+
+wasix_context_id_t ctx1;
+int was_in_two = 0;
+
+void context2_fn(void) {
+  was_in_two++;
+  wasix_context_switch(ctx1);
+  assert(0 && "Should not return to context 2");
+}
+
+void context1_fn(void) {
+  wasix_context_id_t ctx2;
+  int ret = wasix_context_create(&ctx2, context2_fn);
+  assert(ret == 0 && "Failed to create context 2");
+  wasix_context_switch(ctx2);
+  wasix_context_destroy(ctx2);
+  wasix_context_switch(wasix_context_main);
+}
+
+int was_in_context_fn_switch_to_main = 0;
+void context_fn_switch_to_main(void) {
+  was_in_context_fn_switch_to_main = 1;
+  wasix_context_switch(wasix_context_main);
+  assert(0);
+}
+
+// Test a simple context switching scenario
+int test_basic_switching() {
+  // Create three contexts
+  int ret = wasix_context_create(&ctx1, context1_fn);
+  assert(ret == 0 && "Failed to create context 1");
+
+  wasix_context_switch(ctx1);
+
+  assert(was_in_two == 1 && "Context 2 was not executed exactly once");
+
+  return 0;
+}
+
+
+
+int vfork_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;
+    }
+}
+
+// Test that vfork works even after other contexts are active
+int vfork_after_switching()
+{
+    wasix_context_id_t ctx;
+    int ret = wasix_context_create(&ctx, context_fn_switch_to_main);
+    assert(ret == 0 && "Failed to create context");
+    wasix_context_switch(ctx);
+
+    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;
+    }
+}
+
+// Test that vfork works even after other contexts are active
+int vfork_after_switching2()
+{
+    // Create two contexts. One is to verify switching works now and the other to verify it works later on.
+    wasix_context_id_t ctx_a, ctx_b;
+    int ret = wasix_context_create(&ctx_a, context_fn_switch_to_main);
+    assert(ret == 0 && "Failed to create context");
+    ret = wasix_context_create(&ctx_b, context_fn_switch_to_main);
+    assert(ret == 0 && "Failed to create context");
+
+    // Verify that switching works before vfork
+    was_in_context_fn_switch_to_main = 0;
+    wasix_context_switch(ctx_a);
+    assert(was_in_context_fn_switch_to_main == 1 && "Context function was not executed");
+    
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        // The process created by vfork should not have a context switching environment
+        // so we get a ENOSYS here
+        int ret = wasix_context_switch(ctx_b);
+        if (ret != -1) {
+          exit(11);
+        }
+        if (errno != ENOTSUP) {
+          exit(12);
+        }
+
+        execl("./main.wasm", "main.wasm", "subprocess_with_switching", NULL);
+        perror("execl");
+        exit(10);
+    }
+    else
+    {
+        // The parent should still be in the same context switching environment
+        was_in_context_fn_switch_to_main = 0;
+        wasix_context_switch(ctx_b);
+        assert(was_in_context_fn_switch_to_main == 1 && "Context function was not executed");
+
+        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;
+    }
+}
+
+// Test that vfork works even after other contexts are active
+int fork_after_switching()
+{
+    // Create two contexts. One is to verify switching works now and the other to verify it works later on.
+    wasix_context_id_t ctx_a, ctx_b;
+    int ret = wasix_context_create(&ctx_a, context_fn_switch_to_main);
+    assert(ret == 0 && "Failed to create context");
+    ret = wasix_context_create(&ctx_b, context_fn_switch_to_main);
+    assert(ret == 0 && "Failed to create context");
+
+    // Verify that switching works before vfork
+    was_in_context_fn_switch_to_main = 0;
+    wasix_context_switch(ctx_a);
+    assert(was_in_context_fn_switch_to_main == 1 && "Context function was not executed");
+    
+    int pid = fork();
+
+    if (pid == 0)
+    {
+        // The process created by fork should have a new context switching environment
+        // so we get a EINVAL here because the context does not exist in this new environment
+        int ret = wasix_context_switch(ctx_b);
+        if (ret != -1) {
+          exit(11);
+        }
+        if (errno != EINVAL) {
+          exit(12);
+        }
+        // Recreate the context in the child process
+        ret = wasix_context_create(&ctx_b, context_fn_switch_to_main);
+        assert(ret == 0 && "Failed to create context");
+
+        // Now we can switch to it. Switching back to main should work too.
+        was_in_context_fn_switch_to_main = 0;
+        wasix_context_switch(ctx_b);
+        assert(was_in_context_fn_switch_to_main == 1 && "Context function was not executed");
+
+        // exec should always bring us in a new context switching environment
+        execl("./main.wasm", "main.wasm", "subprocess_with_switching", NULL);
+        perror("execl");
+        exit(10);
+    }
+    else
+    {
+        // The parent should still be in the same context switching environment
+        was_in_context_fn_switch_to_main = 0;
+        wasix_context_switch(ctx_b);
+        assert(was_in_context_fn_switch_to_main == 1 && "Context function was not executed");
+
+        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;
+    }
+}
+
+void context_fn_that_executes_fork_and_vfork()
+{
+    int pid = fork();
+    assert(pid == -1 && "fork should fail in a context");
+    assert(errno == ENOTSUP && "fork should return ENOTSUP in a context");
+    pid = vfork();
+    assert(pid == -1 && "vfork should fail in a context");
+    assert(errno == ENOTSUP && "vfork should return ENOTSUP in a context");
+    wasix_context_switch(wasix_context_main);
+    assert(0 && "Should not return to this context");
+}
+
+int fork_and_vfork_only_work_in_main_context()
+{
+    wasix_context_id_t ctx;
+    int ret = wasix_context_create(&ctx, context_fn_that_executes_fork_and_vfork);
+    assert(ret == 0 && "Failed to create context");
+    ret = wasix_context_switch(ctx);
+    assert(ret == 0 && "Failed to switch to context");
+    return 0;
+}
+
+extern char **environ;
+void context_fn_posix_spawn_a_forking_subprocess_from_a_context()
+{
+    int pid;
+    int status;
+    int exit_code;
+
+    // Test a subprocess that does context switching
+    char *argV[] = {"./main.wasm", "subprocess_with_switching",(char *) 0};
+    posix_spawn(&pid, "./main.wasm", NULL, NULL, argV, environ);
+    waitpid(pid, &status, 0);
+    exit_code = WEXITSTATUS(status);
+    assert(exit_code == 20 && "Expected exit code 20 from subprocess");
+
+    // Test a subprocess that does fork and vfork
+    char *argV2[] = {"./main.wasm", "subprocess_with_fork_and_vfork",(char *) 0};
+    posix_spawn(&pid, "./main.wasm", NULL, NULL, argV2, environ);
+    waitpid(pid, &status, 0);
+    exit_code = WEXITSTATUS(status);
+    assert(exit_code == 20 && "Expected exit code 20 from subprocess");
+
+    wasix_context_switch(wasix_context_main);
+    assert(0 && "Should not return to this context");
+}
+
+int posix_spawning_a_forking_subprocess_from_a_context()
+{
+    wasix_context_id_t ctx;
+    int ret = wasix_context_create(&ctx, context_fn_posix_spawn_a_forking_subprocess_from_a_context);
+    assert(ret == 0 && "Failed to create context");
+    ret = wasix_context_switch(ctx);
+    assert(ret == 0 && "Failed to switch to context");
+    return 0;
+}
+
+int subprocess()
+{
+    return 20;
+}
+
+// Test a simple context switching scenario
+int subprocess_with_switching() {
+  test_basic_switching();
+
+  return 20;
+}
+
+// Test a simple context switching scenario
+int subprocess_with_fork_and_vfork() {
+  vfork_after_switching2();
+
+  fork_after_switching();
+
+  return 20;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        return -1;
+    }
+
+
+    if (!strcmp(argv[1], "subprocess"))
+    {
+        return subprocess();
+    }
+    else if (!strcmp(argv[1], "subprocess_with_switching"))
+    {
+        return subprocess_with_switching();
+    }
+        else if (!strcmp(argv[1], "subprocess_with_fork_and_vfork"))
+    {
+        return subprocess_with_fork_and_vfork();
+    }
+    else     if (!strcmp(argv[1], "basic_switching"))
+    {
+        return test_basic_switching();
+    }
+    else if (!strcmp(argv[1], "vfork_after_switching"))
+    {
+        return vfork_after_switching();
+    }
+    else if (!strcmp(argv[1], "vfork_after_switching2"))
+    {
+        return vfork_after_switching2();
+    }
+        else if (!strcmp(argv[1], "fork_after_switching"))
+    {
+        return fork_after_switching();
+    }
+    else if (!strcmp(argv[1], "fork_and_vfork_only_work_in_main_context"))
+    {
+        return fork_and_vfork_only_work_in_main_context();
+    }
+        else if (!strcmp(argv[1], "posix_spawning_a_forking_subprocess_from_a_context"))
+    {
+        return posix_spawning_a_forking_subprocess_from_a_context();
+    }
+        else if (!strcmp(argv[1], "fork_and_vfork_only_work_in_main_context2"))
+    {
+        return fork_and_vfork_only_work_in_main_context();
+    }
+        else if (!strcmp(argv[1], "fork_and_vfork_only_work_in_main_context2"))
+    {
+        return fork_and_vfork_only_work_in_main_context();
+    }
+    else
+    {
+        printf("bad command %s\n", argv[1]);
+        return 1;
+    }
+}
diff --git a/tests/wasix/context-switching/run.sh b/tests/wasix/context-switching/run.sh
new file mode 100755
index 0000000000..410e09ea02
--- /dev/null
+++ b/tests/wasix/context-switching/run.sh
@@ -0,0 +1,8 @@
+set -e
+
+$WASMER_RUN main.wasm --volume . -- basic_switching
+$WASMER_RUN main.wasm --volume . -- vfork_after_switching
+$WASMER_RUN main.wasm --volume . -- vfork_after_switching2
+$WASMER_RUN main.wasm --volume . -- fork_after_switching
+$WASMER_RUN main.wasm --volume . -- fork_and_vfork_only_work_in_main_context
+$WASMER_RUN main.wasm --volume . -- posix_spawning_a_forking_subprocess_from_a_context
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..c822f39d4d
--- /dev/null
+++ b/tests/wasix/create-and-remove-dirs/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm --volume . > 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..e3d39afafd
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd-with-chdir/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm --volume . > 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..e3d39afafd
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm --volume . > 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..648bf66fe3
--- /dev/null
+++ b/tests/wasix/create-move-open/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm --volume . > 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..617b751ce7
--- /dev/null
+++ b/tests/wasix/cross-fs-rename/run.sh
@@ -0,0 +1,6 @@
+TEMP_DIR1=$(mktemp -d)
+TEMP_DIR2=$(mktemp -d)
+
+$WASMER_RUN main.wasm --volume $TEMP_DIR1:/temp1 --volume $TEMP_DIR2:/temp2 > output
+
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/cwd-to-home/run.sh b/tests/wasix/cwd-to-home/run.sh
index e3f5a60846..c85e36cf47 100755
--- a/tests/wasix/cwd-to-home/run.sh
+++ b/tests/wasix/cwd-to-home/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --dir=. > output
+$WASMER_RUN main.wasm --volume . > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+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..810052d915
--- /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_RUN main.wasm --volume .
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..0d4576395f
--- /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;
+}
diff --git a/tests/wasix/dl-needed/run.sh b/tests/wasix/dl-needed/run.sh
new file mode 100755
index 0000000000..8e5b3dd314
--- /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_RUN main.wasm --volume .
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..bc9abf029c
--- /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_RUN main.wasm --volume .
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..997bdafeb9
--- /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;
+}
diff --git a/tests/wasix/dlopen/run.sh b/tests/wasix/dlopen/run.sh
new file mode 100755
index 0000000000..aaf3e3b4f9
--- /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_RUN main.wasm --volume .
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/epoll-create-ctl-wait/run.sh b/tests/wasix/epoll-create-ctl-wait/run.sh
index 3e033fb898..67acc16cf4 100755
--- a/tests/wasix/epoll-create-ctl-wait/run.sh
+++ b/tests/wasix/epoll-create-ctl-wait/run.sh
@@ -1,3 +1,3 @@
-$WASMER -q run main.wasm > output
+$WASMER_RUN main.wasm > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/exception/main.cc b/tests/wasix/exception/main.cc
new file mode 100644
index 0000000000..b2d9e16c16
--- /dev/null
+++ b/tests/wasix/exception/main.cc
@@ -0,0 +1,26 @@
+#include <iostream>
+
+void bar() { throw 40; }
+
+void foo() { bar(); }
+
+void baz() {
+  try {
+    foo();
+  } catch (int &e) {
+    e += 2;
+    std::cout << "caught exception, will rethrow" << std::endl;
+    throw;
+  }
+}
+
+int main() {
+  try {
+    baz();
+  } catch (int myNum) {
+    std::cout << "caught exception in main: " << myNum << std::endl;
+    return myNum;
+  }
+
+  return 1;
+}
diff --git a/tests/wasix/exception/run.sh b/tests/wasix/exception/run.sh
new file mode 100755
index 0000000000..88b2d53eab
--- /dev/null
+++ b/tests/wasix/exception/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm > output
+
+printf "caught exception, will rethrow\ncaught exception in main: 42\n" | diff -u output - 1>/dev/null
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..d12544a46c
--- /dev/null
+++ b/tests/wasix/fd-close/run.sh
@@ -0,0 +1,3 @@
+set -e
+
+$WASMER_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..0ab5d76a2a
--- /dev/null
+++ b/tests/wasix/fork/run.sh
@@ -0,0 +1,4 @@
+set -e
+
+$WASMER_RUN main.wasm --volume . -- failing_exec
+$WASMER_RUN main.wasm --volume . -- 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..648bf66fe3
--- /dev/null
+++ b/tests/wasix/fstatat-with-chdir/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm --volume . > output
+
+rm -rf test1 test2 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/mount-tmp-locally/run.sh b/tests/wasix/mount-tmp-locally/run.sh
index b0e7668118..02da83a220 100755
--- a/tests/wasix/mount-tmp-locally/run.sh
+++ b/tests/wasix/mount-tmp-locally/run.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/tmp:. > output
+$WASMER_RUN main.wasm --volume=.:/tmp > output
 
 printf "0" | diff -u output - 1>/dev/null && \
-rmdir my_test_dir 2>/dev/null
\ No newline at end of file
+rmdir my_test_dir 2>/dev/null
diff --git a/tests/wasix/msync-end-of-file/run.sh b/tests/wasix/msync-end-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/msync-end-of-file/run.sh
+++ b/tests/wasix/msync-end-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/msync-middle-of-file/run.sh b/tests/wasix/msync-middle-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/msync-middle-of-file/run.sh
+++ b/tests/wasix/msync-middle-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/msync-start-of-file/run.sh b/tests/wasix/msync-start-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/msync-start-of-file/run.sh
+++ b/tests/wasix/msync-start-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/munmap-sync-end-of-file/run.sh b/tests/wasix/munmap-sync-end-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/munmap-sync-end-of-file/run.sh
+++ b/tests/wasix/munmap-sync-end-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/munmap-sync-middle-of-file/run.sh b/tests/wasix/munmap-sync-middle-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/munmap-sync-middle-of-file/run.sh
+++ b/tests/wasix/munmap-sync-middle-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/munmap-sync-start-of-file/run.sh b/tests/wasix/munmap-sync-start-of-file/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/munmap-sync-start-of-file/run.sh
+++ b/tests/wasix/munmap-sync-start-of-file/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
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..fc0f9aa8bf
--- /dev/null
+++ b/tests/wasix/pipes/run.sh
@@ -0,0 +1,3 @@
+set -e
+
+$WASMER_RUN main.wasm --volume .
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..e8a212afef
--- /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_RUN main-not-asyncified.wasm --volume .
diff --git a/tests/wasix/proc-exec/run.sh b/tests/wasix/proc-exec/run.sh
index 2f9d5723c8..1f9e67401c 100755
--- a/tests/wasix/proc-exec/run.sh
+++ b/tests/wasix/proc-exec/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/code:. > output
+$WASMER_RUN main.wasm --volume=.:/code > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/proc-exec2/run.sh b/tests/wasix/proc-exec2/run.sh
index 2f9d5723c8..1f9e67401c 100755
--- a/tests/wasix/proc-exec2/run.sh
+++ b/tests/wasix/proc-exec2/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/code:. > output
+$WASMER_RUN main.wasm --volume=.:/code > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/pwrite-and-size/run.sh b/tests/wasix/pwrite-and-size/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/pwrite-and-size/run.sh
+++ b/tests/wasix/pwrite-and-size/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
diff --git a/tests/wasix/read-after-munmap/run.sh b/tests/wasix/read-after-munmap/run.sh
index ba9a2d77c2..3127b0da6d 100755
--- a/tests/wasix/read-after-munmap/run.sh
+++ b/tests/wasix/read-after-munmap/run.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/data:. > output
+$WASMER_RUN main.wasm --volume=.:/data > output
 
 printf "0" | diff -u output - 1>/dev/null
 
-rm my_file.txt
\ No newline at end of file
+rm my_file.txt
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..3500513cf1
--- /dev/null
+++ b/tests/wasix/setjmp-longjmp/run.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+$WASMER_RUN main.wasm
diff --git a/tests/wasix/share-tmp-after-fork/run.sh b/tests/wasix/share-tmp-after-fork/run.sh
index 2f9d5723c8..1f9e67401c 100755
--- a/tests/wasix/share-tmp-after-fork/run.sh
+++ b/tests/wasix/share-tmp-after-fork/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/code:. > output
+$WASMER_RUN main.wasm --volume=.:/code > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/share-tmp-after-proc-exec/run.sh b/tests/wasix/share-tmp-after-proc-exec/run.sh
index 2f9d5723c8..1f9e67401c 100755
--- a/tests/wasix/share-tmp-after-proc-exec/run.sh
+++ b/tests/wasix/share-tmp-after-proc-exec/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/code:. > output
+$WASMER_RUN main.wasm --volume=.:/code > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/share-tmp-after-proc-exec2/run.sh b/tests/wasix/share-tmp-after-proc-exec2/run.sh
index 2f9d5723c8..1f9e67401c 100755
--- a/tests/wasix/share-tmp-after-proc-exec2/run.sh
+++ b/tests/wasix/share-tmp-after-proc-exec2/run.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$WASMER -q run main.wasm --mapdir=/code:. > output
+$WASMER_RUN main.wasm --volume=.:/code > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/dev/null
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..d4240b80bb
--- /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 --volume . &> 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/signal/run.sh b/tests/wasix/signal/run.sh
index 3e033fb898..67acc16cf4 100755
--- a/tests/wasix/signal/run.sh
+++ b/tests/wasix/signal/run.sh
@@ -1,3 +1,3 @@
-$WASMER -q run main.wasm > output
+$WASMER_RUN main.wasm > output
 
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
+printf "0" | diff -u output - 1>/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..b5df5d560c
--- /dev/null
+++ b/tests/wasix/socket_pair/run.sh
@@ -0,0 +1 @@
+$WASMER_RUN main.wasm
diff --git a/tests/wasix/test.sh b/tests/wasix/test.sh
index 1d85eba2b1..59005bfa39 100755
--- a/tests/wasix/test.sh
+++ b/tests/wasix/test.sh
@@ -1,91 +1,42 @@
 #!/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"
-
+export WASMER="$(realpath "../../target/release/wasmer")"
 status=0
-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 bash -c "$cmd"; then
-        printf "\rTesting $dir ✅\n"
-    else
-        printf "\rTesting $dir ❌\n"
-        status=1
-    fi
-done < <(find . -mindepth 1 -maxdepth 1 -type d | sort)
-
-exit $status
\ No newline at end of file
+run_tests() {
+    local backend="$1"
+    export WASMER_RUN="${WASMER} run -q ${backend}"
+
+    printf "\n\nStarting WASIX Test Suite ($backend):\n"
+    while read dir; do
+        dir=$(basename "$dir")
+        printf "Testing $backend: $dir...\r"
+
+        if [ -e "$dir/.no-build" ]; then
+            cmd="cd $dir; \
+                find . -name 'output*' | xargs rm -f; \
+                ./run.sh"
+        else
+            cmd="cd $dir; \
+                find . -name 'output*' | xargs rm -f; \
+                find . -name '*.wasm' | xargs rm -f; \
+                if [ -f main.cc ]; \
+                  then wasix++ -fwasm-exceptions main.cc -o main.wasm; \
+                  else wasixcc main.c -o main.wasm; \
+                fi; \
+                ./run.sh"
+        fi
+
+        if bash -c "$cmd"; then
+            printf "Testing $backend: $dir ✅\n"
+        else
+            printf "Testing $backend: $dir ❌\n"
+            status=1
+        fi
+    done < <(find . -mindepth 1 -maxdepth 1 -type d | sort)
+}
+
+# Call the function with the desired backend argument
+run_tests "--llvm"
+run_tests "--cranelift"
+
+exit $status
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..c4e390e6e3
--- /dev/null
+++ b/tests/wasix/udp/run.sh
@@ -0,0 +1,6 @@
+set -e
+
+$WASMER_RUN main.wasm --net --volume . -- addr-reuse
+$WASMER_RUN main.wasm --net --volume . -- ipv6
+$WASMER_RUN main.wasm --net --volume . -- autobind-connect
+$WASMER_RUN main.wasm --net --volume . -- autobind-sendto
diff --git a/tests/wasix/vfork/.no-build b/tests/wasix/vfork/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/vfork/main.c b/tests/wasix/vfork/main.c
new file mode 100644
index 0000000000..7d0d53e65d
--- /dev/null
+++ b/tests/wasix/vfork/main.c
@@ -0,0 +1,498 @@
+#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 nested_vfork()
+{
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        int pid2 = vfork();
+        if (pid2 != -1)
+        {
+            // A nested vfork should always fail
+            exit(13);
+        }
+        int err = errno;
+        if (err != ENOTSUP)
+        {
+            // errno should be set to EAGAIN
+            printf("Expected errno to be ENOTSUP (%d), got %d\n", ENOTSUP, err);
+            exit(14);
+        }
+        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;
+    }
+
+    __builtin_trap();
+
+    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;
+        }
+
+        __builtin_trap();
+
+        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], "nested_vfork"))
+    {
+        return nested_vfork();
+    }
+    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..f728885dd3
--- /dev/null
+++ b/tests/wasix/vfork/run.sh
@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -e
+
+echo ""
+echo "Note: runtime errors reported from wasmer for this test are expected"
+
+# Test the asyncify based vfork implementation
+WASIXCC_WASM_EXCEPTIONS=no WASIXCC_PIC=no wasixcc main.c -o main.wasm
+
+$WASMER_RUN main.wasm --volume . -- successful_exec
+$WASMER_RUN main.wasm --volume . -- successful_execlp
+$WASMER_RUN main.wasm --volume . -- failing_exec
+$WASMER_RUN main.wasm --volume . -- cloexec
+$WASMER_RUN main.wasm --volume . -- nested_vfork
+$WASMER_RUN main.wasm --volume . -- exiting_child
+$WASMER_RUN main.wasm --volume . -- trapping_child
+# This test is triggering undefined behaviour
+$WASMER_RUN main.wasm --volume . -- exit_before_exec || true
+# This test is triggering undefined behaviour as well
+$WASMER_RUN main.wasm --volume . -- trap_before_exec || true
+
+# Test the setjmp/longjmp based vfork implementation
+WASIXCC_WASM_EXCEPTIONS=yes WASIXCC_PIC=yes wasixcc main.c -o main-eh.wasm -Wl,-pie
+
+$WASMER_RUN main-eh.wasm --volume . -- successful_exec
+$WASMER_RUN main-eh.wasm --volume . -- successful_execlp
+$WASMER_RUN main-eh.wasm --volume . -- failing_exec
+$WASMER_RUN main-eh.wasm --volume . -- cloexec
+$WASMER_RUN main-eh.wasm --volume . -- nested_vfork
+$WASMER_RUN main-eh.wasm --volume . -- exiting_child
+$WASMER_RUN main-eh.wasm --volume . -- trapping_child
+# This test is triggering undefined behaviour
+$WASMER_RUN main-eh.wasm --volume . -- exit_before_exec || true
+# This test is triggering undefined behaviour as well
+$WASMER_RUN main-eh.wasm --volume . -- trap_before_exec || true
diff --git a/tests/wasmer-argus/Cargo.toml b/tests/wasmer-argus/Cargo.toml
index 39bddde419..4d9f87194d 100644
--- a/tests/wasmer-argus/Cargo.toml
+++ b/tests/wasmer-argus/Cargo.toml
@@ -12,23 +12,23 @@ version.workspace = true
 wasmer_lib = ["dep:wasmer"]
 
 [dependencies]
-indicatif = "0.17.8"
-anyhow = "1.0.80"
-log = "0.4.21"
-cynic = "3.4.3"
-url = "2.5.0"
-futures = "0.3.30"
-tracing = "0.1.40"
-tokio = { version = "1.36.0", features = ["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"
+wasmer = { version = "7.0.0", path = "../../lib/api", features = ["core", "singlepass", "cranelift", "llvm"], optional = true }
+indicatif.workspace = true
+anyhow.workspace = true
+log.workspace = true
+cynic.workspace = true
+url.workspace = true
+futures.workspace = true
+tokio = { workspace = true, features = ["rt", "macros", "rt-multi-thread", "sync", "time", "fs"] }
+clap = {workspace = true, features = ["derive", "string"]}
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+serde.workspace = true
+serde_json.workspace = 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..e3c7007203 100644
--- a/tests/wasmer-argus/src/argus/mod.rs
+++ b/tests/wasmer-argus/src/argus/mod.rs
@@ -9,14 +9,14 @@ use reqwest::header::CONTENT_TYPE;
 use std::{fs::OpenOptions, io::Write as _, ops::AddAssign, path::Path, sync::Arc, time::Duration};
 use tokio::{
     sync::{
-        mpsc::{self, UnboundedSender},
         Mutex, Semaphore,
+        mpsc::{self, UnboundedSender},
     },
     task::JoinSet,
 };
 use tracing::*;
 use url::Url;
-use wasmer_api::{types::PackageVersionWithPackage, WasmerClient};
+use wasmer_backend_api::{WasmerClient, types::PackageVersionWithPackage};
 
 #[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..d72a81b980 100644
--- a/tests/wasmer-argus/src/argus/packages.rs
+++ b/tests/wasmer-argus/src/argus/packages.rs
@@ -2,7 +2,7 @@ use super::Argus;
 use crate::ArgusConfig;
 use futures::StreamExt;
 use indicatif::{ProgressBar, ProgressStyle};
-use reqwest::{header, Client};
+use reqwest::{Client, header};
 use std::{path::PathBuf, sync::Arc, time::Duration};
 use tokio::{
     fs::File,
@@ -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},
 };
@@ -64,13 +64,13 @@ impl Argus {
             count += pkgs.len();
 
             for pkg in pkgs {
-                if self.to_test(&pkg).await {
-                    if let Err(e) = s.send(pkg) {
-                        error!("failed to send packages: {e}");
-                        p.finish_and_clear();
-                        anyhow::bail!("failed to send packages: {e}")
-                    };
-                }
+                if self.to_test(&pkg).await
+                    && let Err(e) = s.send(pkg)
+                {
+                    error!("failed to send packages: {e}");
+                    p.finish_and_clear();
+                    anyhow::bail!("failed to send packages: {e}")
+                };
             }
         }
 
@@ -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();
@@ -109,7 +109,7 @@ impl Argus {
         if !dir_path.exists() {
             tokio::fs::create_dir_all(dir_path).await?;
         } else if dir_path.exists() && !dir_path.is_dir() {
-            anyhow::bail!("path {:?} exists, but it is not a directory!", path)
+            anyhow::bail!("path {path:?} exists, but it is not a directory!")
         }
 
         let client = Client::builder().user_agent(APP_USER_AGENT).build()?;
@@ -123,11 +123,8 @@ impl Argus {
                     .and_then(|ct_len| ct_len.parse().ok())
                     .unwrap_or(0) // Fallback to 0
             } else {
-                anyhow::bail!(
-                    "Couldn't fetch head from URL {}. Error: {:?}",
-                    url,
-                    resp.status()
-                )
+                let status = resp.status();
+                anyhow::bail!("Couldn't fetch head from URL {url}. Error: {status:?}")
             }
         };
 
@@ -156,10 +153,8 @@ impl Argus {
 
                 p.finish_and_clear();
 
-                anyhow::bail!(
-                    "[{test_id}] failed to create file at {:?}. Error: {e}",
-                    path.display()
-                );
+                let path_display = path.display();
+                anyhow::bail!("[{test_id}] failed to create file at {path_display}. Error: {e}");
             }
         };
         let mut download = match request.send().await {
@@ -180,8 +175,7 @@ impl Argus {
                     );
                     p.finish_and_clear();
                     anyhow::bail!(
-                        "[{test_id}] failed to download chunk from {:?}. Error: {e}",
-                        download
+                        "[{test_id}] failed to download chunk from {download:?}. Error: {e}"
                     );
                 }
                 Ok(chunk) => {
@@ -194,8 +188,7 @@ impl Argus {
                             );
                             p.finish_and_clear();
                             anyhow::bail!(
-                                "[{test_id}] failed to write chunk to file {:?}. Error: {e}",
-                                outfile
+                                "[{test_id}] failed to write chunk to file {outfile:?}. Error: {e}"
                             );
                         };
                     } else {
diff --git a/tests/wasmer-argus/src/argus/tester/cli_tester.rs b/tests/wasmer-argus/src/argus/tester/cli_tester.rs
index 548a844160..f6f57240e2 100644
--- a/tests/wasmer-argus/src/argus/tester/cli_tester.rs
+++ b/tests/wasmer-argus/src/argus/tester/cli_tester.rs
@@ -3,8 +3,8 @@ 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 webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
+use wasmer_backend_api::types::PackageVersionWithPackage;
+use webc::{Container, Version, v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3};
 
 use super::{TestReport, Tester};
 
@@ -38,10 +38,10 @@ impl<'a> CLIRunner<'a> {
         dir_path: &Path,
         atom_id: usize,
     ) -> anyhow::Result<Result<(), String>> {
-        if let Err(e) = Command::new(cli_path).arg("-V").output() {
-            if let std::io::ErrorKind::NotFound = e.kind() {
-                anyhow::bail!("the command '{cli_path}' was not found");
-            }
+        if let Err(e) = Command::new(cli_path).arg("-V").output()
+            && let std::io::ErrorKind::NotFound = e.kind()
+        {
+            anyhow::bail!("the command '{cli_path}' was not found");
         }
 
         let atom_path = dir_path.join(format!("atom_{atom_id}.wasm"));
@@ -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
+        });
 
-                out
-            }) {
-                Ok(r) => match r {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                },
-                Err(_) => Err(String::from("thread panicked")),
+        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> {
@@ -117,7 +117,7 @@ impl<'a> CLIRunner<'a> {
 
     async fn get_version(&self) -> anyhow::Result<String> {
         let cli_path = match &self.config.cli_path {
-            Some(ref p) => p.clone(),
+            Some(p) => p.clone(),
             None => String::from("wasmer"),
         };
 
@@ -143,12 +143,12 @@ 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?;
         let cli_path = match &self.config.cli_path {
-            Some(ref p) => p.clone(),
+            Some(p) => p.clone(),
             None => String::from("wasmer"),
         };
 
@@ -157,14 +157,14 @@ 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)?;
 
         let webc_v2 = match webc::detect(v2_bytes.as_slice()) {
             Ok(Version::V2) => Container::from(OwnedReader::parse(v2_bytes)?),
             Ok(other) => {
-                return self.err(version, start_time, format!("Unsupported version, {other}"))
+                return self.err(version, start_time, format!("Unsupported version, {other}"));
             }
             Err(e) => return self.err(version, start_time, format!("An error occurred: {e}")),
         };
@@ -182,14 +182,14 @@ 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)?;
 
         let webc_v3 = match webc::detect(v3_bytes.as_slice()) {
             Ok(Version::V3) => Container::from(OwnedReaderV3::parse(v3_bytes)?),
             Ok(other) => {
-                return self.err(version, start_time, format!("Unsupported version, {other}"))
+                return self.err(version, start_time, format!("Unsupported version, {other}"));
             }
             Err(e) => return self.err(version, start_time, format!("An error occurred: {e}")),
         };
diff --git a/tests/wasmer-argus/src/argus/tester/lib_tester.rs b/tests/wasmer-argus/src/argus/tester/lib_tester.rs
index 8d27bd290e..09ce25da1b 100644
--- a/tests/wasmer-argus/src/argus/tester/lib_tester.rs
+++ b/tests/wasmer-argus/src/argus/tester/lib_tester.rs
@@ -4,9 +4,9 @@ use indicatif::ProgressBar;
 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 webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
+use wasmer::{Engine, NativeEngineExt, Target, sys::Features};
+use wasmer_backend_api::types::PackageVersionWithPackage;
+use webc::{Container, Version, v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3};
 
 pub struct LibRunner<'a> {
     pub test_id: u64,
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/wasmer-argus/src/main.rs b/tests/wasmer-argus/src/main.rs
index 18a684c52e..54f79d6a59 100644
--- a/tests/wasmer-argus/src/main.rs
+++ b/tests/wasmer-argus/src/main.rs
@@ -2,7 +2,7 @@ mod argus;
 
 use argus::*;
 use clap::Parser;
-use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
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/exception-handling.wast b/tests/wast/wasmer/exception-handling.wast
new file mode 100644
index 0000000000..77a21674d6
--- /dev/null
+++ b/tests/wast/wasmer/exception-handling.wast
@@ -0,0 +1,30 @@
+(module
+  (func $fn (result i32 exnref)
+    i32.const 42
+    ref.null exn)
+  (func (export "main") (result i32)
+    (call $fn)
+    (drop))
+)
+(assert_return (invoke "main") (i32.const 42))
+
+(module
+  (func $fn (result f64 exnref i32) f64.const 0 ref.null exn i32.const 0)
+)
+
+(module
+  (func (export "return_42") (result i64)
+    (block
+        br 0
+        (try_table)
+    )
+    i64.const 42)
+)
+(assert_return (invoke "return_42") (i64.const 42))
+
+(module
+  (func (result funcref exnref i32)
+    ref.null func
+    ref.null exn
+    i32.const 0)
+)
diff --git a/tests/wast/wasmer/multivalue-issue.wast b/tests/wast/wasmer/multivalue-issue.wast
new file mode 100644
index 0000000000..14176ad09f
--- /dev/null
+++ b/tests/wast/wasmer/multivalue-issue.wast
@@ -0,0 +1,15 @@
+(module
+  (func (export "large-sig-no-params")
+    (result i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+    (i64.const 1) (i64.const 2) (i64.const 3) (i64.const 4)
+    (i64.const 5) (i64.const 6) (i64.const 7) (i64.const 8)
+    (i64.const 9) (i64.const 10) (i64.const 11) (i64.const 12)
+  )
+)
+
+(assert_return
+  (invoke "large-sig-no-params")
+  (i64.const 1) (i64.const 2) (i64.const 3) (i64.const 4)
+  (i64.const 5) (i64.const 6) (i64.const 7) (i64.const 8)
+  (i64.const 9) (i64.const 10) (i64.const 11) (i64.const 12)
+)
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/riscv-issues.wast b/tests/wast/wasmer/riscv-issues.wast
new file mode 100644
index 0000000000..4ec0b31f81
--- /dev/null
+++ b/tests/wast/wasmer/riscv-issues.wast
@@ -0,0 +1,17 @@
+(module (memory 1)
+  (func (export "leu-with-memory") (result i32)
+    (local i32)
+    ;; save the constant to memory
+    (i32.const 0)
+    i32.const -1294967296 ;; 3000000000
+    i32.store
+    ;; load it from the memory location
+    (i32.const 0)
+    i32.load
+    ;; compare it with a i32 constant
+    i32.const -294967296 ;; 4000000000
+    i32.le_u
+  )
+)
+
+(assert_return (invoke "leu-with-memory") (i32.const 1))
diff --git a/tests/wast/wasmer/simd.wast b/tests/wast/wasmer/simd.wast
new file mode 100644
index 0000000000..e63d34de90
--- /dev/null
+++ b/tests/wast/wasmer/simd.wast
@@ -0,0 +1,4 @@
+(module
+  (type (func (result i32 i32 v128)))
+  (func (type 0) i32.const 1 i32.const 2 v128.const i32x4 0 0 0 0)
+)
diff --git a/tests/wast/wasmer/simd_generated_ext_ops.wast b/tests/wast/wasmer/simd_generated_ext_ops.wast
new file mode 100644
index 0000000000..82f604b0cf
--- /dev/null
+++ b/tests/wast/wasmer/simd_generated_ext_ops.wast
@@ -0,0 +1,285 @@
+;; Generated tests for SIMD extended ops using sequential vectors.
+
+(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)))
+  (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)))
+
+  (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_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_s") (param v128 v128) (result v128)
+    (i16x8.extmul_high_i8x16_s (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)))
+
+  (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_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_s") (param v128 v128) (result v128)
+    (i32x4.extmul_high_i16x8_s (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)))
+
+  (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_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_s") (param v128 v128) (result v128)
+    (i64x2.extmul_high_i32x4_s (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)))
+
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128)
+    (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+
+  (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 "i16x8.extend_high_i8x16_u") (param v128) (result v128)
+    (i16x8.extend_high_i8x16_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_high_i16x8_s") (param v128) (result v128)
+    (i32x4.extend_high_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 "i32x4.extend_high_i16x8_u") (param v128) (result v128)
+    (i32x4.extend_high_i16x8_u (local.get 0)))
+
+  (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128)
+    (i64x2.extend_low_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_high_i32x4_u") (param v128) (result v128)
+    (i64x2.extend_high_i32x4_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 "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)))
+
+  (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128)
+    (i32x4.trunc_sat_f64x2_s_zero (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)))
+  (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)))
+)
+
+;; i16x8.extadd_pairwise_i8x16_s/u
+(assert_return
+  (invoke "i16x8.extadd_pairwise_i8x16_s"
+          (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))
+  (v128.const i16x8 3 7 11 15 19 23 27 31))
+(assert_return
+  (invoke "i16x8.extadd_pairwise_i8x16_u"
+          (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))
+  (v128.const i16x8 3 7 11 15 19 23 27 31))
+
+;; i32x4.extadd_pairwise_i16x8_s/u
+(assert_return
+  (invoke "i32x4.extadd_pairwise_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 3 7 11 15))
+(assert_return
+  (invoke "i32x4.extadd_pairwise_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 3 7 11 15))
+
+  ;; i16x8.extmul_low/high_i8x16_s
+  (assert_return
+    (invoke "i16x8.extmul_low_i8x16_s"
+            (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+            (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115))
+    (v128.const i16x8 100 202 306 412 520 630 742 856))
+  (assert_return
+    (invoke "i16x8.extmul_high_i8x16_s"
+            (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+            (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115))
+    (v128.const i16x8 972 1090 1210 1332 1456 1582 1710 1840))
+
+  ;; i16x8.extmul_low/high_i8x16_u
+  (assert_return
+    (invoke "i16x8.extmul_low_i8x16_u"
+            (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+            (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115))
+    (v128.const i16x8 100 202 306 412 520 630 742 856))
+  (assert_return
+    (invoke "i16x8.extmul_high_i8x16_u"
+            (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+            (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115))
+    (v128.const i16x8 972 1090 1210 1332 1456 1582 1710 1840))
+
+;; i32x4.extmul_low/high_i16x8_s/u
+(assert_return
+  (invoke "i32x4.extmul_low_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i32x4 1000 2002 3006 4012))
+(assert_return
+  (invoke "i32x4.extmul_low_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i32x4 1000 2002 3006 4012))
+(assert_return
+  (invoke "i32x4.extmul_high_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i32x4 5020 6030 7042 8056))
+(assert_return
+  (invoke "i32x4.extmul_high_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i32x4 5020 6030 7042 8056))
+
+;; i64x2.extmul_low/high_i32x4_s/u
+(assert_return
+  (invoke "i64x2.extmul_low_i32x4_s"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i64x2 1000 2002))
+(assert_return
+  (invoke "i64x2.extmul_low_i32x4_u"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i64x2 1000 2002))
+(assert_return
+  (invoke "i64x2.extmul_high_i32x4_s"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i64x2 3006 4012))
+(assert_return
+  (invoke "i64x2.extmul_high_i32x4_u"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i64x2 3006 4012))
+
+;; i32x4.dot_i16x8_s
+(assert_return
+  (invoke "i32x4.dot_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i32x4 3002 7018 11050 15098))
+
+;; i16x8.extend_low/high_i8x16
+(assert_return
+  (invoke "i16x8.extend_low_i8x16_s"
+          (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))
+  (v128.const i16x8 1 2 3 4 5 6 7 8))
+(assert_return
+  (invoke "i16x8.extend_low_i8x16_u"
+          (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))
+  (v128.const i16x8 1 2 3 4 5 6 7 8))
+(assert_return
+  (invoke "i16x8.extend_high_i8x16_u"
+          (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))
+  (v128.const i16x8 9 10 11 12 13 14 15 16))
+
+;; i32x4.extend_low/high_i16x8
+(assert_return
+  (invoke "i32x4.extend_low_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 1 2 3 4))
+(assert_return
+  (invoke "i32x4.extend_high_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 5 6 7 8))
+(assert_return
+  (invoke "i32x4.extend_low_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 1 2 3 4))
+(assert_return
+  (invoke "i32x4.extend_high_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8))
+  (v128.const i32x4 5 6 7 8))
+
+;; i64x2.extend_low/high_i32x4
+(assert_return
+  (invoke "i64x2.extend_low_i32x4_s"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const i64x2 1 2))
+(assert_return
+  (invoke "i64x2.extend_low_i32x4_u"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const i64x2 1 2))
+(assert_return
+  (invoke "i64x2.extend_high_i32x4_s"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const i64x2 3 4))
+(assert_return
+  (invoke "i64x2.extend_high_i32x4_u"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const i64x2 3 4))
+
+;; i8x16.narrow_i16x8_s/u
+(assert_return
+  (invoke "i8x16.narrow_i16x8_s"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i8x16 1 2 3 4 5 6 7 8 127 127 127 127 127 127 127 127))
+(assert_return
+  (invoke "i8x16.narrow_i16x8_u"
+          (v128.const i16x8 1 2 3 4 5 6 7 8)
+          (v128.const i16x8 1000 1001 1002 1003 1004 1005 1006 1007))
+  (v128.const i8x16 1 2 3 4 5 6 7 8 255 255 255 255 255 255 255 255))
+
+;; i16x8.narrow_i32x4_s/u
+(assert_return
+  (invoke "i16x8.narrow_i32x4_s"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i16x8 1 2 3 4 1000 1001 1002 1003))
+(assert_return
+  (invoke "i16x8.narrow_i32x4_u"
+          (v128.const i32x4 1 2 3 4)
+          (v128.const i32x4 1000 1001 1002 1003))
+  (v128.const i16x8 1 2 3 4 1000 1001 1002 1003))
+
+;; i32x4.trunc_sat_f64x2_s_zero
+(assert_return
+  (invoke "i32x4.trunc_sat_f64x2_s_zero"
+          (v128.const f64x2 1.0 2.0))
+  (v128.const i32x4 1 2 0 0))
+
+;; f64x2.convert_low_i32x4_s/u
+(assert_return
+  (invoke "f64x2.convert_low_i32x4_s"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const f64x2 1.0 2.0))
+(assert_return
+  (invoke "f64x2.convert_low_i32x4_u"
+          (v128.const i32x4 1 2 3 4))
+  (v128.const f64x2 1.0 2.0))
+
+;; f64x2.promote_low_f32x4
+(assert_return
+  (invoke "f64x2.promote_low_f32x4"
+          (v128.const f32x4 1.0 2.0 3.0 4.0))
+  (v128.const f64x2 1.0 2.0))
+
+;; f32x4.demote_f64x2_zero
+(assert_return
+  (invoke "f32x4.demote_f64x2_zero"
+          (v128.const f64x2 1.0 2.0))
+  (v128.const f32x4 1.0 2.0 0.0 0.0))
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))