diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000000..61534bd0f6
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,7 @@
+[target.riscv64gc-unknown-linux-gnu]
+linker = "riscv64-linux-gnu-gcc"
+runner = "qemu-riscv64 -L /usr/riscv64-linux-gnu/"
+
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"
+runner = "qemu-aarch64 -L /usr/aarch64-linux-gnu/"
diff --git a/.github/cross-linux-riscv64/Dockerfile b/.github/cross-linux-riscv64/Dockerfile
index 94d091f3a6..887dcc6997 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.84
+RUN rustup -v toolchain install 1.90
 # add docker the manual way
 COPY install_docker.sh /
 RUN /install_docker.sh
@@ -61,7 +61,10 @@ 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.84-x86_64-unknown-linux-gnu
+RUN rustup target add riscv64gc-unknown-linux-gnu --toolchain 1.90-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 /
diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml
index d1843c3204..d483b2365d 100644
--- a/.github/workflows/benchmark.yaml
+++ b/.github/workflows/benchmark.yaml
@@ -7,7 +7,7 @@ on:
 
 env:
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.84"
+  MSRV: "1.90"
 
 jobs:
   run_benchmark:
@@ -24,7 +24,7 @@ jobs:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ab546fa51e..911fc2587c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -3,7 +3,7 @@ name: Builds
 env:
   RUST_BACKTRACE: 1
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.84"
+  MSRV: "1.90"
 
 on:
   push:
@@ -51,10 +51,8 @@ jobs:
           - build: linux-arm64
             os: ubuntu-22.04-arm
             artifact_name: "wasmer-linux-aarch64"
-            #llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-aarch64.tar.xz"
+            #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"
-            use_sccache: false
-            use_rustcache: false
             build_wasm: true
             enable_llvm: false
             enable_v8: false
@@ -63,32 +61,29 @@ jobs:
           - build: linux-x64
             os: ubuntu-22.04
             artifact_name: "wasmer-linux-amd64"
-            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz"
+            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"
-            use_sccache: false
             build_wasm: true
             enable_llvm: true
             enable_v8: true
             enable_wasmi: true
             enable_wamr: true
           - build: macos-x64
-            os: macos-13
-            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz"
+            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"
-            use_sccache: false
             build_wasm: false
             enable_llvm: true
             enable_v8: true
             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
             build_wasm: false
-            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz"
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-aarch64.tar.xz"
             enable_llvm: true
             enable_v8: true
             enable_wasmi: true
@@ -96,10 +91,9 @@ jobs:
           - build: windows-x64
             os: windows-2022
             artifact_name: "wasmer-windows-amd64"
-            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz"
+            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
-            use_sccache: false
             enable_llvm: true
             enable_v8: false
             enable_wasmi: true
@@ -115,18 +109,17 @@ jobs:
             #  enable_wasmi: true
             #  enable_wamr: false
 
-    container: ${{ matrix.container }}
     env:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
       TARGET: ${{ matrix.target }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Set up base deps on musl
         if: startsWith(matrix.build, 'linux-musl-x64')
         run: |
-          apk add bash mold make curl cmake ninja clang18 zstd-static llvm18-dev clang18-static llvm18-static ncurses-static zlib-static libxml2-dev libxml2-static xz-dev xz-static xz-libs libc++-dev libc++-static
-          ln -s /usr/bin/clang-18 /usr/bin/clang
+          apk add bash mold 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: |
@@ -162,11 +155,9 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
-          target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v2
-        if: ${{ matrix.use_sccache != true && matrix.use_rustcache != false }}
-      - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.os == 'macos-13' && !matrix.llvm_url
+          target: ${{ matrix.target }}      
+      - name: Install LLVM (macOS Intel)
+        if: matrix.os == 'macos-15-intel' && !matrix.llvm_url
         run: |
           brew install llvm
       - name: Install LLVM
@@ -185,14 +176,14 @@ jobs:
         shell: bash
         run: |
           LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
-          echo LLVM_SYS_180_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'
+        if: matrix.os == 'macos-14' || matrix.os == 'depot-macos-14'
       - name: Set up dependencies for Mac OS
         run: |
           brew install automake
@@ -206,18 +197,6 @@ jobs:
             ~/.cargo/registry
             ~/.cargo/git
           key: ${{ matrix.build }}-${{ matrix.target }}-cargo-${{ hashFiles('Cargo.lock') }}-v1
-      - uses: actions/cache@v4
-        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
@@ -226,42 +205,14 @@ 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: |
-          LLVM_CONFIG_PATH=/usr/bin/llvm-config-18 make package-capi-headless
+          LLVM_CONFIG_PATH=/usr/bin/llvm-config-21 make package-capi-headless
       - name: Build C API
         shell: bash
         run: |
-          LLVM_CONFIG_PATH=/usr/bin/llvm-config-18 make build-capi
+          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
@@ -286,9 +237,9 @@ jobs:
         run: |
           echo "#!/bin/bash" >> /usr/bin/llvm-config
           echo 'if [ "$1" = "--libs" ]; then' >> /usr/bin/llvm-config
-          echo 'llvm-config-18 "$@" "--link-static"' >> /usr/bin/llvm-config
+          echo 'llvm-config-21 "$@" "--link-static"' >> /usr/bin/llvm-config
           echo "else" >> /usr/bin/llvm-config
-          echo 'llvm-config-18 "$@"' >> /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
@@ -341,7 +292,7 @@ jobs:
     if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Windows-GNU linker
         shell: bash
         run: |
@@ -408,9 +359,9 @@ jobs:
   darwin_aarch64_jsc:
     name: macOS aarch64 (JSC)
     if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
-    runs-on: macos-13
+    runs-on: depot-macos-14
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: aarch64-apple-darwin
@@ -442,9 +393,9 @@ jobs:
   darwin_x86_64_jsc:
     name: macOS x86_64 (JSC)
     if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
-    runs-on: macos-13
+    runs-on: macos-15-intel
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: x86_64-apple-darwin
@@ -474,7 +425,7 @@ jobs:
     if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: riscv64gc-unknown-linux-gnu
@@ -483,6 +434,15 @@ jobs:
           docker build -t wasmer/riscv64 ${GITHUB_WORKSPACE}/.github/cross-linux-riscv64/
         env:
           CROSS_DOCKER_IN_DOCKER: true
+      - name: "Run wast test suite for all compilers"
+        run: test-stage-0-wast
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64:latest cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
       - name: Build Wasmer binary
         run: |
           make build-wasmer
diff --git a/.github/workflows/cache-bucket-cleanup.yaml b/.github/workflows/cache-bucket-cleanup.yaml
index 224a2a94b4..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@v5
+        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 06d421295c..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@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
diff --git a/.github/workflows/cifuzz.yaml b/.github/workflows/cifuzz.yaml
deleted file mode 100644
index ef1b9dfc38..0000000000
--- a/.github/workflows/cifuzz.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-# 
-# [todo] xdoardo (2024/10/17): 
-#
-#  We updated our MSRV and llvm, so we need to open a pr here
-#  https://github.com/google/oss-fuzz/blob/fb88de8bd2d220662271aabbe19427dc24134bf6/projects/wasmer/build.sh
-#  before re-enabling this.
-#
-#
-# name: CIFuzz
-# on: [pull_request]
-# jobs:
-#  Fuzzing:
-#    runs-on: ubuntu-latest
-#    steps:
-#    - name: Build Fuzzers
-#      id: build
-#      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
-#      with:
-#        oss-fuzz-project-name: 'wasmer'
-#        language: rust
-#    - name: Run Fuzzers
-#      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
-#      with:
-#        oss-fuzz-project-name: 'wasmer'
-#        language: rust
-#        fuzz-seconds: 300
-#    - name: Upload Crash
-#      uses: actions/upload-artifact@v4
-#      if: failure() && steps.build.outcome == 'success'
-#      with:
-#        name: artifacts
-#        path: ./out/artifacts
diff --git a/.github/workflows/cloudcompiler.yaml b/.github/workflows/cloudcompiler.yaml
index 3ab284dd67..535efd1dd8 100644
--- a/.github/workflows/cloudcompiler.yaml
+++ b/.github/workflows/cloudcompiler.yaml
@@ -2,7 +2,7 @@ name: Release cloudcompiler.wasm
 
 env:
   RUST_BACKTRACE: 1
-  MSRV: "1.84"
+  MSRV: "1.90"
 
 on:
   push:
@@ -16,14 +16,13 @@ jobs:
     name: Set up
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
-          target: ${{ matrix.target }}
       - name: Install wasm32-wasip1 target
         shell: bash
         run: |
diff --git a/.github/workflows/documentation.yaml b/.github/workflows/documentation.yaml
index 6dc04948f3..33a9b2d361 100644
--- a/.github/workflows/documentation.yaml
+++ b/.github/workflows/documentation.yaml
@@ -8,14 +8,14 @@ on:
       - "lib/**"
 
 env:
-  MSRV: "1.84"
+  MSRV: "1.90"
 
 jobs:
   documentation:
     name: Documentation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -27,10 +27,10 @@ jobs:
           mkdir ${{ env.LLVM_DIR }}
           tar xf llvm.tar.xz --strip-components=1 -C ${{ env.LLVM_DIR }}
           echo "${{ env.LLVM_DIR }}/bin" >> $GITHUB_PATH
-          echo "LLVM_SYS_180_PREFIX=${{ env.LLVM_DIR }}" >> $GITHUB_ENV
+          echo "LLVM_SYS_211_PREFIX=${{ env.LLVM_DIR }}" >> $GITHUB_ENV
         env:
-          LLVM_DIR: ${{ github.workspace }}/llvm-18
-          LLVM_URL: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.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 c75a37cce8..e6d1922ff2 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -24,10 +24,11 @@ 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.84"
+  MSRV: "1.90"
   NEXTEST_PROFILE: "ci"
   RUSTUP_WINDOWS_PATH_ADD_BIN: 1
   WASI_SDK_VERSION: "22"
+  S3_CACHE_VERSION: "3"
 
 jobs:
   setup:
@@ -52,30 +53,32 @@ jobs:
     name: Code lint
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
           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/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o /opt/llvm.tar.xz
-          mkdir -p /opt/llvm-18
-          tar xf /opt/llvm.tar.xz --strip-components=1 -C /opt/llvm-18
-          echo '/opt/llvm-18/bin' >> $GITHUB_PATH
-          echo 'LLVM_SYS_180_PREFIX=/opt/llvm-18' >> $GITHUB_ENV
+          curl --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 +91,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,16 +101,16 @@ jobs:
     name: cargo-deny
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - 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@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -123,10 +127,10 @@ jobs:
           make test-js
 
   test_wasi_fyi:
-    name: Test wasi-fyi
+    name: Wasi-fyi
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -135,16 +139,16 @@ jobs:
       - name: Install wasm-pack
         run: |
           curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: Install LLVM 18
+      - name: Install LLVM 21
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          curl --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_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "LLVM_SYS_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
       - name: make test-wasi-fyi
@@ -157,16 +161,15 @@ jobs:
       #     make test-js-core
 
   test_wasix:
-    name: Test WASIX
+    name: WASIX
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
       - name: Install Tools
-        # note: llvm-19 for building wasix-libc, llvm-18 later for building wasmer
         run: |
           sudo apt-get update
           sudo apt-get install -y git make lld curl
@@ -190,14 +193,15 @@ jobs:
         run: |
           export RUST_LOG=wasixcc=trace
           export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-          rustup toolchain install 1.89 --profile minimal --no-self-update
-          cargo +1.89 install wasixcc -F bin
+          rustup toolchain install 1.90 --profile minimal --no-self-update
+          cargo +1.90 install wasixcc -F bin
           mkdir wasixcc-install
           wasixcc --install-executables ./wasixcc-install
           echo "$(pwd)/wasixcc-install" >> $GITHUB_PATH
           mkdir -p ~/.wasixcc/llvm
           mkdir -p ~/.wasixcc/sysroot
-          wasixcc --download-all
+          wasixcc --download-sysroot v2025-11-06.1
+          wasixcc --download-llvm
 
       - name: Tool versions
         run: |
@@ -205,16 +209,16 @@ jobs:
           echo "llvm version: $(wasixcc -- --version)"
           echo "wasm-opt version: $(wasm-opt --version)"
 
-      - name: Install LLVM 18 (for building Wasmer)
+      - name: Install LLVM 21 (for building Wasmer)
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          curl --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_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "LLVM_SYS_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
 
@@ -222,36 +226,31 @@ jobs:
         run: |
           WASI_SDK=~/wasi-sdk WASIX_SYSROOT=$(pwd)/sysroot/wasix-sysroot/sysroot make test-wasix
 
-  test_wasm_build:
-    name: Test wasm build
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v5
-      - name: rustup target add wasm32-wasip1
-        run: rustup target add wasm32-wasip1
-      - name: make build-wasmer-wasm
-        run: make build-wasmer-wasm
-
   test_build_jsc:
-    name: Test JSC build
+    name: JSC
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
           target: x86_64-unknown-linux-gnu
+          components: clippy
       - name: Install NodeJS
         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: lint jsc
+        run: make lint-jsc
+
       - name: make build-wasmer-jsc
         run: make build-wasmer-jsc
 
   test_interpreter_api:
-    name: ${{ matrix.build-what.name }} on ${{ matrix.metadata.build }}
+    name: ${{ matrix.build-what.name }} - ${{ matrix.metadata.build }}
     runs-on: ${{ matrix.metadata.os }}
     strategy:
       fail-fast: false
@@ -260,23 +259,26 @@ jobs:
           [
             {
               key: wamr,
+              lint-cmd: "make lint-wamr",
               build-cmd: "make test-wamr-api",
-              name: "Test API for wamr feature",
+              name: "API (wamr)",
             },
             {
               key: wasmi,
+              lint-cmd: "make lint-wasmi",
               build-cmd: "make test-wasmi-api",
-              name: "Test API for wasmi feature",
+              name: "API (wasmi)",
             },
             {
               key: v8,
+              lint-cmd: "make lint-v8",
               build-cmd: "make test-v8-api",
-              name: "Test API for v8 feature",
+              name: "API (v8)",
             },
           ]
         metadata: [
             { build: linux-x64, os: ubuntu-22.04 },
-            { build: macos-arm, os: macos-14 },
+            { build: macos-arm, os: depot-macos-14 },
             #{
             #  build: windows-x64,
             #  os: windows-2022,
@@ -284,7 +286,7 @@ jobs:
           ]
     container: ${{ matrix.metadata.container }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Setup MSVC (Windows)
         uses: ilammy/msvc-dev-cmd@v1
@@ -293,6 +295,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
+          components: clippy
 
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
@@ -307,9 +310,9 @@ jobs:
         if: startsWith(matrix.metadata.build, 'macos-')
         shell: bash
         run: |
-          brew install ninja llvm@18
-          echo "/opt/homebrew/opt/llvm@18/bin" >> $GITHUB_PATH
-          ls -laR /opt/homebrew/opt/llvm@18/bin/
+          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-')
@@ -322,6 +325,9 @@ jobs:
         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 }}
@@ -339,13 +345,13 @@ jobs:
         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@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "nightly-2025-02-09"
+          toolchain: "nightly-2025-09-27"
           target: x86_64-unknown-linux-gnu
       - run: cargo install toml-cli --locked # toml-cli is required to run `make test-build-docs-rs`
 
@@ -354,23 +360,23 @@ jobs:
         run: |
           sudo apt-get install ninja-build -y
 
-      - name: Install LLVM 18
+      - name: Install LLVM 21
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          curl --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_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "LLVM_SYS_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
       - name: make test-build-docs-rs-ci
         run: make test-build-docs-rs-ci
 
   build_linux_aarch64:
-    name: ${{ matrix.build-what.name }} on linux-aarch64
+    name: ${{ matrix.build-what.name }} - linux-aarch64
     runs-on: ubuntu-22.04-arm
     strategy:
       fail-fast: false
@@ -380,16 +386,16 @@ jobs:
             {
               key: capi,
               build-cmd: "make build-capi && make package-capi",
-              name: "Build C-API",
+              name: "C-API",
             },
             {
               key: wasmer,
               build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
-              name: "Build wasmer-cli",
+              name: "Wasmer-cli",
             },
           ]
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
@@ -399,7 +405,7 @@ jobs:
           docker build -t wasmer/aarch64 ${GITHUB_WORKSPACE}/.github/cross-linux-aarch64/
         env:
           CROSS_DOCKER_IN_DOCKER: true
-      - name: Build ${{ matrix.build-what.key }}
+      - name: ${{ matrix.build-what.key }}
         run: |
           ${{ matrix.build-what.build-cmd }}
         env:
@@ -431,26 +437,31 @@ jobs:
           retention-days: 2
 
   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: wast-tests,
+              build-cmd: "make test-stage-0-wast",
+              name: "Run WAST tests",
+            },
             {
               key: capi,
               build-cmd: "make build-capi && make package-capi",
-              name: "Build C-API",
+              name: "C-API",
             },
             {
               key: wasmer,
               build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
-              name: "Build wasmer-cli",
+              name: "Wasmer-cli",
             },
           ]
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       #- uses: dtolnay/rust-toolchain@stable
       #  with:
       #    toolchain: ${{ env.MSRV }}
@@ -490,7 +501,7 @@ 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:
@@ -501,22 +512,27 @@ jobs:
             {
               key: capi,
               build-cmd: "make build-capi && make build-capi-headless && make package-capi && make tar-capi",
-              name: "Build and test C-API",
+              name: "C-API",
             },
             {
               key: capi-v8,
               build-cmd: "make test-capi-v8",
-              name: "Build and test C-API with v8",
+              name: "C-API with v8",
             },
             {
               key: wasmer,
               build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
-              name: "Build wasmer-cli",
+              name: "Wasmer-cli",
+            },
+            {
+              key: "check",
+              build-cmd: "make check",
+              name: "Wasmer API (sys)",
             },
             {
               key: "api-feats",
               build-cmd: "make check-api-features",
-              name: "Check wasmer API with all sys features enabled",
+              name: "API (sys)",
             },
           ]
         metadata: [
@@ -525,7 +541,7 @@ jobs:
               os: ubuntu-22.04,
               target: x86_64-unknown-linux-gnu,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz",
+              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.
@@ -533,18 +549,18 @@ jobs:
             },
             {
               build: macos-x64,
-              os: macos-13,
+              os: macos-15-intel,
               target: x86_64-apple-darwin,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz",
+              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: macos-14,
+              os: depot-macos-14,
               target: aarch64-apple-darwin,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-aarch64.tar.xz",
               supports_v8: true,
             },
             {
@@ -552,8 +568,7 @@ jobs:
               os: windows-2022,
               target: x86_64-pc-windows-msvc,
               exe: ".exe",
-              # For now, disable LLVM in `windows-x64.`
-              # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-windows-amd64.tar.xz",
               supports_v8: false,
             },
             {
@@ -567,7 +582,7 @@ jobs:
               target: x86_64-unknown-linux-musl,
               os: ubuntu-22.04,
               exe: "",
-              container: "alpine:latest",
+              container: "alpine:edge",
               supports_v8: false,
             },
           ]
@@ -576,7 +591,9 @@ jobs:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v5
+      - 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: |
@@ -586,22 +603,20 @@ jobs:
       - name: Set up base deps on musl
         if: matrix.metadata.build == 'linux-musl'
         run: |
-          ./scripts/alpine-linux-install-deps.sh 
-          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
-          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
-        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
+          ./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-13'
+        if: matrix.metadata.os == 'macos-15-intel'
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
           target: ${{ matrix.metadata.target }}
+          components: rustfmt,clippy
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
       - name: Install MSVC dev-cmd (Windows)
@@ -644,8 +659,8 @@ jobs:
           mkdir -p package
           mkdir -p package/winsdk
           cp -r /tmp/winsdk/* package/winsdk
-      - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.metadata.os == 'macos-13' && !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
@@ -659,7 +674,7 @@ jobs:
           echo "ENABLE_LLVM=1" >> $GITHUB_ENV
           echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
           echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
-          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "LLVM_SYS_211_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
       - name: Add `brew` libs to `RUSTFLAGS`
@@ -687,13 +702,14 @@ jobs:
         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 }}
@@ -704,18 +720,18 @@ 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: Test C-API (v8)
+      - 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 }}
@@ -723,20 +739,31 @@ jobs:
           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' }}
+        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 == '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 == '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 }}
@@ -758,7 +785,7 @@ 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:
@@ -767,27 +794,27 @@ jobs:
         stage:
           [
             {
-              description: "Run wast test suite for all compilers",
+              description: "WAST (all comp.)",
               make: "test-stage-0-wast",
             },
             {
-              description: "Unit-test packages on std",
+              description: "Packages - std",
               make: "test-stage-1-test-all",
             },
             {
-              description: "Unit-test cranelift on no-std",
+              description: "Cranelift - no-std",
               make: "test-stage-2-test-compiler-cranelift-nostd",
             },
             {
-              description: "Unit-test singlepass on no-std",
+              description: "Singlepass - no-std",
               make: "test-stage-3-test-compiler-singlepass-nostd",
             },
             {
-              description: "Unit-test wasmer-cli",
+              description: "Wasmer-cli",
               make: "test-stage-4-wasmer-cli",
             },
             {
-              description: "Unit-test examples",
+              description: "Examples",
               make: "test-stage-5-test-examples",
             },
           ]
@@ -797,36 +824,35 @@ jobs:
               os: ubuntu-22.04,
               target: x86_64-unknown-linux-gnu,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-linux-amd64.tar.xz",
             },
             {
               build: macos-x64,
-              os: macos-13,
+              os: macos-15-intel,
               target: x86_64-apple-darwin,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/21.x/llvm-darwin-amd64.tar.xz",
             },
             {
               build: macos-arm,
-              os: macos-14,
+              os: depot-macos-14,
               target: aarch64-apple-darwin,
               exe: "",
-              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz",
+              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",
-              # For now, disable LLVM in `windows-x64.`
-              # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+              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:latest",
+              container: "alpine:edge",
             },
           ]
     container: ${{ matrix.metadata.container }}
@@ -834,7 +860,10 @@ jobs:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
+      - 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: |
@@ -845,9 +874,6 @@ jobs:
         if: matrix.metadata.build == 'linux-musl'
         run: |
           ./scripts/alpine-linux-install-deps.sh
-          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
-          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
-        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
       - name: Install MSVC dev-cmd (Windows)
         uses: ilammy/msvc-dev-cmd@v1
         if: ${{ matrix.metadata.build == 'windows-x64' }}
@@ -862,7 +888,7 @@ jobs:
           # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
           brew install gnu-tar zstd
           echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
-        if: matrix.metadata.os == 'macos-13'
+        if: matrix.metadata.os == 'macos-15-intel'
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -870,8 +896,8 @@ jobs:
           target: ${{ matrix.metadata.target }}
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
-      - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.metadata.os == 'macos-13' && !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
@@ -885,12 +911,12 @@ jobs:
           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_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          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'
+        if: matrix.metadata.os == 'macos-14' || matrix.metadata.os == 'depot-macos-14'
         shell: bash
         run: |
           echo "RUSTFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
@@ -905,12 +931,15 @@ jobs:
           EOF
         if: matrix.metadata.target
       - name: Cache
+        # TODO: fix disk space issue for a couple of Linux runners
+        if: ${{ !(matrix.stage.make == 'test-stage-5-test-examples' && (matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'linux-x64')) }}
+        # 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 }}
@@ -921,13 +950,15 @@ jobs:
       - 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]
     strategy:
@@ -937,30 +968,30 @@ jobs:
           - build: linux-x64
             os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
-            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz"
-          - build: macos-x64
-            os: macos-13
-            target: x86_64-apple-darwin
+            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-14
+            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-latest
             target: x86_64-pc-windows-msvc
-            # For now, disable LLVM in `windows-x64.`
-            # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+            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@v5
+      - uses: actions/checkout@v6
       - uses: goto-bus-stop/setup-zig@v2
         with:
           version: 0.10.0
@@ -968,9 +999,6 @@ jobs:
         if: matrix.build == 'linux-musl'
         run: |
           ./scripts/alpine-linux-install-deps.sh
-          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
-          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
-        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
       - uses: actions/download-artifact@v4
         id: download
         with:
@@ -984,16 +1012,17 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
-          target: ${{ matrix.metadata.target }}
+          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 }}
@@ -1018,18 +1047,14 @@ jobs:
         with:
           name: capi-macos-arm
           path: package/cache/wasmercache3
-      - uses: actions/download-artifact@v4
-        with:
-          name: capi-macos-x64
-          path: package/cache/wasmercache4
       - uses: actions/download-artifact@v4
         with:
           name: capi-linux-x64
-          path: package/cache/wasmercache5
+          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: |
@@ -1042,8 +1067,7 @@ jobs:
           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
+          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:
@@ -1059,11 +1083,6 @@ jobs:
         with:
           name: capi-macos-arm
           path: download_link
-      - uses: actions/download-artifact@v4
-        if: ${{ matrix.build == 'macos-x64' }}
-        with:
-          name: capi-macos-x64
-          path: download_link
       - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'linux-x64' }}
         with:
@@ -1130,9 +1149,11 @@ jobs:
           #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   test-wasmer-integration-tests:
+    name: "Remote integ. tests"
     needs: [build]
     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.WAPM_DEV_TOKEN }}
+      token: ${{ secrets.PROD_BACKEND_CIUSER_TOKEN }}
diff --git a/.github/workflows/wasmer-config.yaml b/.github/workflows/wasmer-config.yaml
index 6ace3c11a8..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@v5
+      - uses: actions/checkout@v6
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Setup Rust
@@ -41,7 +41,7 @@ jobs:
     name: Linting and Formatting
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Setup Rust
diff --git a/.gitignore b/.gitignore
index f6deb5be7f..0d9278440f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@
 .DS_Store
 .idea
 .gdb_history
-/.cargo/
 **/.vscode/*
 !/.vscode/settings.json
 api-docs-repo/
diff --git a/Cargo.lock b/Cargo.lock
index 4aa3620eb4..895acadf9c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,7 +8,7 @@ version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
- "gimli 0.32.3",
+ "gimli",
 ]
 
 [[package]]
@@ -28,29 +28,6 @@ dependencies = [
  "cpufeatures",
 ]
 
-[[package]]
-name = "ahash"
-version = "0.7.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
-dependencies = [
- "getrandom 0.2.16",
- "once_cell",
- "version_check",
-]
-
-[[package]]
-name = "ahash"
-version = "0.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
-dependencies = [
- "cfg-if",
- "once_cell",
- "version_check",
- "zerocopy 0.8.27",
-]
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -66,6 +43,12 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -172,43 +155,44 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "askama"
-version = "0.12.1"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28"
+checksum = "5d4744ed2eef2645831b441d8f5459689ade2ab27c854488fbab1fbe94fce1a7"
 dependencies = [
  "askama_derive",
- "askama_escape",
+ "itoa",
+ "percent-encoding",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
 name = "askama_derive"
-version = "0.12.5"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83"
+checksum = "d661e0f57be36a5c14c48f78d09011e67e0cb618f269cca9f2fd8d15b68c46ac"
 dependencies = [
  "askama_parser",
  "basic-toml",
- "mime",
- "mime_guess",
+ "memchr",
  "proc-macro2",
  "quote",
+ "rustc-hash",
  "serde",
- "syn 2.0.106",
+ "serde_derive",
+ "syn 2.0.111",
 ]
 
-[[package]]
-name = "askama_escape"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341"
-
 [[package]]
 name = "askama_parser"
-version = "0.2.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0"
+checksum = "cf315ce6524c857bb129ff794935cf6d42c82a6cff60526fe2a63593de4d0d4f"
 dependencies = [
- "nom 7.1.3",
+ "memchr",
+ "serde",
+ "serde_derive",
+ "winnow",
 ]
 
 [[package]]
@@ -233,13 +217,12 @@ dependencies = [
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.17"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bd389a4b2970a01282ee455294913c0a43724daedcd1a24c3eb0ec1c1320b66"
+checksum = "bcbb6924530aa9e0432442af08bbcafdad182db80d2e560da42a6d442535bf85"
 dependencies = [
  "anstyle",
- "bstr 1.12.0",
- "doc-comment",
+ "bstr 1.12.1",
  "libc",
  "predicates 3.1.3",
  "predicates-core",
@@ -280,7 +263,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -315,6 +298,49 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "axum"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b098575ebe77cb6d14fc7f32749631a6e44edbef6b796f89b020e99ba20d425"
+dependencies = [
+ "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 = "axum-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
+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.76"
@@ -330,6 +356,12 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -362,11 +394,11 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.70.1"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -375,9 +407,9 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "shlex",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -388,9 +420,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.4"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "blake3"
@@ -427,12 +459,12 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
  "memchr",
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
  "serde",
 ]
 
@@ -450,6 +482,9 @@ name = "bumpalo"
 version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+dependencies = [
+ "allocator-api2",
+]
 
 [[package]]
 name = "bus"
@@ -462,40 +497,18 @@ dependencies = [
  "parking_lot_core",
 ]
 
-[[package]]
-name = "bytecheck"
-version = "0.6.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
-dependencies = [
- "bytecheck_derive 0.6.12",
- "ptr_meta 0.1.4",
- "simdutf8",
-]
-
 [[package]]
 name = "bytecheck"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0caa33a2c0edca0419d15ac723dff03f1956f7978329b1e3b5fdaaaed9d3ca8b"
 dependencies = [
- "bytecheck_derive 0.8.2",
- "ptr_meta 0.3.1",
+ "bytecheck_derive",
+ "ptr_meta",
  "rancor",
  "simdutf8",
 ]
 
-[[package]]
-name = "bytecheck_derive"
-version = "0.6.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "bytecheck_derive"
 version = "0.8.2"
@@ -504,7 +517,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -515,39 +528,29 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "bytesize"
-version = "1.3.3"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e93abca9e28e0a1b9877922aacb20576e05d4679ffa78c3d6dc22a26a216659"
+checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "bzip2"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47"
-dependencies = [
- "bzip2-sys",
-]
-
-[[package]]
-name = "bzip2-sys"
-version = "0.1.13+1.0.8"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
 dependencies = [
- "cc",
- "pkg-config",
+ "libbz2-rs-sys",
 ]
 
 [[package]]
@@ -568,18 +571,41 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "cargo-platform"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "122ec45a44b270afd1402f351b782c676b173e3c3fb28d86ff7ebfb4d86a4ee4"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "cargo_metadata"
-version = "0.15.4"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
 dependencies = [
  "camino",
- "cargo-platform",
+ "cargo-platform 0.1.9",
  "semver 1.0.27",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef987d17b0a113becdd19d3d0022d04d7ef41f9efe4f3fb63ac44ba61df3ade9"
+dependencies = [
+ "camino",
+ "cargo-platform 0.3.1",
+ "semver 1.0.27",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -590,27 +616,27 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cbindgen"
-version = "0.27.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fce8dd7fcfcbf3a0a87d8f515194b49d6135acab73e18bd380d1d93bb1a15eb"
+checksum = "befbfd072a8e81c02f8c507aefce431fe5e7d051f83d48a23ffc9b9fe5a11799"
 dependencies = [
- "heck 0.4.1",
- "indexmap 2.11.4",
+ "heck 0.5.0",
+ "indexmap 2.12.1",
  "log",
  "proc-macro2",
  "quote",
  "serde",
  "serde_json",
- "syn 2.0.106",
+ "syn 2.0.111",
  "tempfile",
- "toml 0.8.23",
+ "toml",
 ]
 
 [[package]]
 name = "cc"
-version = "1.2.40"
+version = "1.2.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d05d92f4b1fd76aad469d46cdd858ca761576082cd37df81416691e50199fb"
+checksum = "c481bdbf0ed3b892f6f806287d72acd515b352a4ec27a208489b8c1bc839633a"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -629,9 +655,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
@@ -676,7 +702,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
  "ciborium-io",
- "half 2.6.0",
+ "half 2.7.1",
 ]
 
 [[package]]
@@ -702,9 +728,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.11"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfaff671f6b22ca62406885ece523383b9b64022e341e53e009a62ebc47a45f2"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -712,48 +738,48 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.11"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a216b506622bb1d316cd51328dce24e07bdff4a6128a47c7e7fad11878d5adbb"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim 0.10.0",
+ "strsim 0.11.1",
 ]
 
 [[package]]
 name = "clap_complete"
-version = "4.5.3"
+version = "4.5.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5a2d6eec27fce550d708b2be5d798797e5a55b246b323ef36924a0001996352"
+checksum = "39615915e2ece2550c0149addac32fb5bd312c657f43845bb9088cb9c8a7c992"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.4.7"
+version = "4.5.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
 dependencies = [
- "heck 0.4.1",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.6.0"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "clap_mangen"
-version = "0.2.29"
+version = "0.2.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27b4c3c54b30f0d9adcb47f25f61fcce35c4dd8916638c6b82fbd5f4fb4179e2"
+checksum = "439ea63a92086df93893164221ad4f24142086d535b3a0957b9b9bea2dc86301"
 dependencies = [
  "clap",
  "roff",
@@ -776,34 +802,22 @@ checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "colored"
-version = "1.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f741c91823341bebf717d4c71bda820630ce065443b58bd1b7451af008355"
-dependencies = [
- "is-terminal",
- "lazy_static",
- "winapi",
-]
-
-[[package]]
-name = "colored"
-version = "2.2.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
+checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
 dependencies = [
- "lazy_static",
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "comfy-table"
-version = "7.1.4"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
+checksum = "b03b7db8e0b4b2fdad6c551e634134e99ec000e5c8c3b6856c65e8bbaded7a3b"
 dependencies = [
  "crossterm",
  "unicode-segmentation",
- "unicode-width 0.2.2",
+ "unicode-width",
 ]
 
 [[package]]
@@ -813,15 +827,15 @@ dependencies = [
  "pretty_assertions",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.111",
  "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",
@@ -836,7 +850,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "tester",
- "winapi",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -874,10 +888,62 @@ dependencies = [
  "encode_unicode",
  "libc",
  "once_cell",
- "unicode-width 0.2.2",
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "console"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b430743a6eb14e9764d4260d4c0d8123087d504eeb9c48f2b2a5e810dd369df4"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "console-api"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8599749b6667e2f0c910c1d0dff6901163ff698a52d5a39720f61b5be4b20d3"
+dependencies = [
+ "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 = "constant_time_eq"
 version = "0.3.1"
@@ -918,9 +984,9 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "corosensei"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "878ba85678ef5d34ffe1b5da981b0828232b4c7f2726b20984f59c7e79f6d514"
+checksum = "1d46a43097861058cb45affe888e40ba19b57a8210650144cdc7b50c9d87840a"
 dependencies = [
  "autocfg",
  "cfg-if",
@@ -938,28 +1004,47 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cranelift-assembler-x64"
+version = "0.126.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30054f4aef4d614d37f27d5b77e36e165f0b27a71563be348e7c9fcfac41eed8"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+]
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.126.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beab56413879d4f515e08bcf118b1cb85f294129bb117057f573d37bfbb925a"
+dependencies = [
+ "cranelift-srcgen",
+]
+
 [[package]]
 name = "cranelift-bforest"
-version = "0.110.2"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "305d51c180ebdc46ef61bc60c54ae6512db3bc9a05842a1f1e762e45977019ab"
+checksum = "6d054747549a69b264d5299c8ca1b0dd45dc6bd0ee43f1edfcc42a8b12952c7a"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.110.3"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "690d8ae6c73748e5ce3d8fe59034dceadb8823e6c8994ba324141c5eae909b0e"
+checksum = "98b92d481b77a7dc9d07c96e24a16f29e0c9c27d042828fdf7e49e54ee9819bf"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.110.2"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd7ca95e831c18d1356da783765c344207cbdffea91e13e47fa9327dbb2e0719"
+checksum = "6eeccfc043d599b0ef1806942707fc51cdd1c3965c343956dc975a55d82a920f"
 dependencies = [
  "bumpalo",
+ "cranelift-assembler-x64",
  "cranelift-bforest",
  "cranelift-bitset",
  "cranelift-codegen-meta",
@@ -967,66 +1052,79 @@ dependencies = [
  "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
- "gimli 0.28.1",
- "hashbrown 0.14.5",
+ "gimli",
+ "hashbrown 0.15.5",
  "log",
+ "pulley-interpreter",
  "regalloc2",
- "rustc-hash 1.1.0",
+ "rustc-hash",
+ "serde",
  "smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
+ "wasmtime-internal-math",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.110.3"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0a2d2ab65e6cbf91f81781d8da65ec2005510f18300eff21a99526ed6785863"
+checksum = "1174cdb9d9d43b2bdaa612a07ed82af13db9b95526bc2c286c2aec4689bcc038"
 dependencies = [
+ "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck 0.5.0",
+ "pulley-interpreter",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.110.3"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efcff860573cf3db9ae98fbd949240d78b319df686cc306872e7fab60e9c84d7"
+checksum = "7d572be73fae802eb115f45e7e67a9ed16acb4ee683b67c4086768786545419a"
 
 [[package]]
 name = "cranelift-control"
-version = "0.110.3"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d70e5b75c2d5541ef80a99966ccd97aaa54d2a6af19ea31759a28538e1685a"
+checksum = "e1587465cc84c5cc793b44add928771945f3132bbf6b3621ee9473c631a87156"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.110.2"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a48cb0a194c9ba82fec35a1e492055388d89b2e3c03dee9dcf2488892be8004d"
+checksum = "063b83448b1343e79282c3c7cbda7ed5f0816f0b763a4c15f7cecb0a17d87ea6"
 dependencies = [
  "cranelift-bitset",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.110.2"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8327afc6c1c05f4be62fefce5b439fa83521c65363a322e86ea32c85e7ceaf64"
+checksum = "aa4461c2d2ca48bc72883f5f5c3129d9aefac832df1db824af9db8db3efee109"
 dependencies = [
  "cranelift-codegen",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.5",
  "log",
  "smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
 ]
 
 [[package]]
 name = "cranelift-isle"
-version = "0.110.2"
+version = "0.126.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56b08621c00321efcfa3eee6a3179adc009e21ea8d24ca7adc3c326184bc3f48"
+checksum = "acd811b25e18f14810d09c504e06098acc1d9dbfa24879bf0d6b6fb44415fc66"
+
+[[package]]
+name = "cranelift-srcgen"
+version = "0.126.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d039de901c8d928222b8128e1b9a9ab27b82a7445cb749a871c75d9cb25c57d"
 
 [[package]]
 name = "crc"
@@ -1054,9 +1152,9 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "e1c047a62b0cc3e145fa84415a3191f628e980b194c2755aa12300a4e6cbd928"
 dependencies = [
  "anes",
  "cast",
@@ -1064,16 +1162,11 @@ dependencies = [
  "clap",
  "criterion-plot",
  "csv",
- "is-terminal",
- "itertools 0.10.5",
+ "itertools 0.13.0",
  "num-traits",
- "once_cell",
  "oorandom",
- "plotters",
- "rayon",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -1081,12 +1174,12 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "9b1bcc0dc7dfae599d84ad0b1a55f80cde8af3725da8313b528da95ef783e338"
 dependencies = [
  "cast",
- "itertools 0.10.5",
+ "itertools 0.13.0",
 ]
 
 [[package]]
@@ -1134,14 +1227,15 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crossterm"
-version = "0.28.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "crossterm_winapi",
+ "document-features",
  "parking_lot",
- "rustix 0.38.44",
+ "rustix",
  "winapi",
 ]
 
@@ -1172,35 +1266,25 @@ dependencies = [
 
 [[package]]
 name = "csv"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
 dependencies = [
  "csv-core",
  "itoa",
  "ryu",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "csv-core"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d02f3b0da4c6504f86e9cd789d8dbafab48c2321be74e9987593de5a894d93d"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
 dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ctor"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
-dependencies = [
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "cynic"
 version = "3.12.0"
@@ -1229,7 +1313,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.10.0",
- "syn 2.0.106",
+ "syn 2.0.111",
  "thiserror 1.0.69",
 ]
 
@@ -1239,7 +1323,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3136ed6464e975162667c08092fcb54947ce08785fca301162fd614c4dfd974f"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "lalrpop-util",
  "logos",
 ]
@@ -1253,17 +1337,7 @@ dependencies = [
  "cynic-codegen",
  "darling 0.20.11",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "darling"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
-dependencies = [
- "darling_core 0.14.4",
- "darling_macro 0.14.4",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1286,20 +1360,6 @@ dependencies = [
  "darling_macro 0.21.3",
 ]
 
-[[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 0.10.0",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "darling_core"
 version = "0.20.11"
@@ -1311,7 +1371,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.11.1",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1324,18 +1384,7 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
-dependencies = [
- "darling_core 0.14.4",
- "quote",
- "syn 1.0.109",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1346,7 +1395,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core 0.20.11",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1357,20 +1406,7 @@ checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
  "darling_core 0.21.3",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if",
- "hashbrown 0.14.5",
- "lock_api",
- "once_cell",
- "parking_lot_core",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1399,11 +1435,52 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26bf8fc351c5ed29b5c2f0cbbac1b209b74f60ecd62e675a998df72c49af5204"
 
+[[package]]
+name = "defmt"
+version = "0.3.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0963443817029b2024136fc4dd07a5107eb8f977eaf18fcd1fdeb11306b64ad"
+dependencies = [
+ "defmt 1.0.1",
+]
+
+[[package]]
+name = "defmt"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "548d977b6da32fa1d1fda2876453da1e7df63ad0304c8b3dae4dbe7b96f39b78"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d4fc12a85bcf441cfe44344c4b72d58493178ce635338a3f3b78943aceb258e"
+dependencies = [
+ "defmt-parser",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror 2.0.17",
+]
+
 [[package]]
 name = "deranged"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
 dependencies = [
  "powerfmt",
 ]
@@ -1416,49 +1493,38 @@ checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[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.111",
 ]
 
 [[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",
-]
-
-[[package]]
-name = "derive_more"
-version = "0.99.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1478,20 +1544,19 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
  "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.1",
  "shell-words",
  "tempfile",
- "thiserror 1.0.69",
  "zeroize",
 ]
 
@@ -1520,9 +1585,9 @@ dependencies = [
 
 [[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",
 ]
@@ -1539,13 +1604,14 @@ dependencies = [
 
 [[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",
+ "option-ext",
+ "redox_users 0.5.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1555,7 +1621,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 dependencies = [
  "libc",
- "redox_users",
+ "redox_users 0.4.6",
  "winapi",
 ]
 
@@ -1567,26 +1633,20 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
-[[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.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 dependencies = [
  "litrs",
 ]
@@ -1621,13 +1681,13 @@ version = "4.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a31e49f416ec431ceef002ee220eee9da97687ec3ecea8040703edbaa75e157"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "byteorder",
  "lazy_static",
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1639,7 +1699,7 @@ dependencies = [
  "byteorder",
  "dynasm",
  "fnv",
- "memmap2 0.9.8",
+ "memmap2 0.9.9",
 ]
 
 [[package]]
@@ -1651,7 +1711,7 @@ dependencies = [
  "enum-ordinalize",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1668,42 +1728,42 @@ 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.111",
 ]
 
 [[package]]
 name = "enum-ordinalize"
-version = "4.3.0"
+version = "4.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5"
+checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
 dependencies = [
  "enum-ordinalize-derive",
 ]
 
 [[package]]
 name = "enum-ordinalize-derive"
-version = "4.3.1"
+version = "4.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff"
+checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1724,14 +1784,14 @@ dependencies = [
  "darling 0.21.3",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "env_filter"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
 dependencies = [
  "log",
 ]
@@ -1760,11 +1820,13 @@ 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]]
@@ -1810,16 +1872,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
-[[package]]
-name = "fern"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9f0c14694cbd524c8720dd69b0e3179344f04ebb5f90f2e4a440c6ea3b2f1ee"
-dependencies = [
- "colored 1.9.4",
- "log",
-]
-
 [[package]]
 name = "field-offset"
 version = "0.3.6"
@@ -1844,9 +1896,9 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0399f9d26e5191ce32c498bebd31e7a3ceabc2745f0ac54af3f335126c3f24b3"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "fixedbitset"
@@ -1856,11 +1908,12 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flate2"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
+ "libz-rs-sys",
  "miniz_oxide",
 ]
 
@@ -1888,6 +1941,18 @@ 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"
@@ -2011,7 +2076,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2052,9 +2117,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.7"
+version = "0.14.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
 dependencies = [
  "typenum",
  "version_check",
@@ -2066,7 +2131,7 @@ version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
 dependencies = [
- "unicode-width 0.2.2",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2084,45 +2149,48 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
  "r-efi",
- "wasi 0.14.7+wasi-0.2.4",
+ "wasip2",
  "wasm-bindgen",
 ]
 
 [[package]]
-name = "ghost"
-version = "0.1.20"
+name = "gimli"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1323e4e10ffd5d48a21ea37f8d4e3b15dd841121d1301a86122fa0984bedf0a"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "fallible-iterator",
+ "indexmap 2.12.1",
+ "stable_deref_trait",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.28.1"
+name = "git-version"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19"
 dependencies = [
- "fallible-iterator",
- "indexmap 2.11.4",
- "stable_deref_trait",
+ "git-version-macro",
 ]
 
-[[package]]
-name = "gimli"
-version = "0.32.3"
+[[package]]
+name = "git-version-macro"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
 
 [[package]]
 name = "glob"
@@ -2132,14 +2200,14 @@ checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "globset"
-version = "0.4.16"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
 dependencies = [
  "aho-corasick",
- "bstr 1.12.0",
+ "bstr 1.12.1",
  "log",
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
  "regex-syntax",
 ]
 
@@ -2193,6 +2261,25 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "h2"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap 2.12.1",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
 [[package]]
 name = "half"
 version = "1.8.3"
@@ -2201,12 +2288,13 @@ checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
 
 [[package]]
 name = "half"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "zerocopy 0.8.27",
 ]
 
 [[package]]
@@ -2240,54 +2328,64 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.11.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-dependencies = [
- "ahash 0.7.8",
-]
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "ahash 0.8.12",
+ "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.12",
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
-name = "hashbrown"
-version = "0.15.5"
+name = "hdrhistogram"
+version = "7.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+checksum = "765c9198f173dd59ce26ff9f95ef0aafd0a0fe01fb9d72841bc5066a4c06511d"
+dependencies = [
+ "base64 0.21.7",
+ "byteorder",
+ "flate2",
+ "nom 7.1.3",
+ "num-traits",
+]
 
 [[package]]
-name = "hashbrown"
-version = "0.16.0"
+name = "heapless"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
 
 [[package]]
 name = "heapless"
-version = "0.8.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+checksum = "2af2455f757db2b292a9b1768c4b70186d443bcb3b316252d6b540aec1cd89ed"
 dependencies = [
  "hash32",
  "stable_deref_trait",
@@ -2308,6 +2406,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -2340,12 +2444,11 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
 dependencies = [
  "bytes",
- "fnv",
  "itoa",
 ]
 
@@ -2402,14 +2505,15 @@ checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
 
 [[package]]
 name = "hyper"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
  "atomic-waker",
  "bytes",
  "futures-channel",
  "futures-core",
+ "h2",
  "http",
  "http-body",
  "httparse",
@@ -2436,7 +2540,20 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.2",
+ "webpki-roots 1.0.3",
+]
+
+[[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",
 ]
 
 [[package]]
@@ -2472,11 +2589,11 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bytes",
  "futures-channel",
  "futures-core",
@@ -2488,7 +2605,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.0",
+ "socket2",
  "tokio",
  "tower-service",
  "tracing",
@@ -2520,9 +2637,9 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
 dependencies = [
  "displaydoc",
  "potential_utf",
@@ -2533,9 +2650,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -2546,11 +2663,10 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
 dependencies = [
- "displaydoc",
  "icu_collections",
  "icu_normalizer_data",
  "icu_properties",
@@ -2561,42 +2677,38 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
 
 [[package]]
 name = "icu_properties"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
 dependencies = [
- "displaydoc",
  "icu_collections",
  "icu_locale_core",
  "icu_properties_data",
  "icu_provider",
- "potential_utf",
  "zerotrie",
  "zerovec",
 ]
 
 [[package]]
 name = "icu_properties_data"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
 
 [[package]]
 name = "icu_provider"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
- "stable_deref_trait",
- "tinystr",
  "writeable",
  "yoke",
  "zerofrom",
@@ -2639,15 +2751,15 @@ dependencies = [
 
 [[package]]
 name = "ignore"
-version = "0.4.23"
+version = "0.4.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
+checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
 dependencies = [
  "crossbeam-deque",
  "globset",
  "log",
  "memchr",
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
  "same-file",
  "walkdir",
  "winapi-util",
@@ -2665,52 +2777,49 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.11.4"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.0",
+ "hashbrown 0.16.1",
  "serde",
  "serde_core",
 ]
 
 [[package]]
 name = "indicatif"
-version = "0.17.11"
+version = "0.18.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
+checksum = "9375e112e4b463ec1b1c6c011953545c65a30164fbab5b581df32b3abf0dcb88"
 dependencies = [
- "console",
- "number_prefix",
+ "console 0.16.1",
  "portable-atomic",
- "unicode-width 0.2.2",
+ "unicode-width",
+ "unit-prefix",
  "web-time",
 ]
 
 [[package]]
 name = "inkwell"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
+version = "0.7.1"
+source = "git+https://github.com/TheDan64/inkwell.git?rev=b9c53276e30935ccec841d12c9687a17e9199958#b9c53276e30935ccec841d12c9687a17e9199958"
 dependencies = [
- "either",
  "inkwell_internals",
  "libc",
  "llvm-sys",
  "once_cell",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
 name = "inkwell_internals"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
+version = "0.12.0"
+source = "git+https://github.com/TheDan64/inkwell.git?rev=b9c53276e30935ccec841d12c9687a17e9199958#b9c53276e30935ccec841d12c9687a17e9199958"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2752,11 +2861,11 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.43.2"
+version = "1.44.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fdb647ebde000f43b5b53f773c30cf9b0cb4300453208713fa38b2c70935a0"
+checksum = "b5c943d4415edd8153251b6f197de5eb1640e56d84e8d9159bea190421c73698"
 dependencies = [
- "console",
+ "console 0.15.11",
  "once_cell",
  "regex",
  "serde",
@@ -2769,7 +2878,7 @@ version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb6250a98af259a26fd5a4a6081fccea9ac116e4c3178acf4aeb86d32d2b7715"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cc",
  "handlebars",
  "lazy_static",
@@ -2781,23 +2890,11 @@ dependencies = [
 
 [[package]]
 name = "inventory"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84344c6e0b90a9e2b6f3f9abe5cc74402684e348df7b32adca28747e0cef091a"
-dependencies = [
- "ctor",
- "ghost",
-]
-
-[[package]]
-name = "io-uring"
-version = "0.7.10"
+version = "0.3.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b"
+checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
 dependencies = [
- "bitflags 2.9.4",
- "cfg-if",
- "libc",
+ "rustversion",
 ]
 
 [[package]]
@@ -2825,22 +2922,11 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "is-terminal"
-version = "0.4.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itertools"
@@ -2853,18 +2939,18 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.12.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
  "either",
 ]
@@ -2881,15 +2967,15 @@ version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.81"
+version = "0.3.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
+checksum = "b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -2931,11 +3017,17 @@ dependencies = [
  "any_ascii",
 ]
 
+[[package]]
+name = "libbz2-rs-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
+
 [[package]]
 name = "libc"
-version = "0.2.176"
+version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -2969,7 +3061,7 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "libc",
  "redox_syscall",
 ]
@@ -2980,6 +3072,15 @@ version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c6639b70a7ce854b79c70d7e83f16b5dc0137cc914f3d7d03803b513ecc67ac"
 
+[[package]]
+name = "libz-rs-sys"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "840db8cf39d9ec4dd794376f38acc40d0fc65eec2a8f484f7fd375b84602becd"
+dependencies = [
+ "zlib-rs",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -2988,19 +3089,13 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linked_hash_set"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bae85b5be22d9843c80e5fc80e9b64c8a3b1f98f867c709956eca3efff4e92e2"
+checksum = "984fb35d06508d1e69fc91050cceba9c0b748f983e6739fa2c7a9237154c52c8"
 dependencies = [
  "linked-hash-map",
 ]
 
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.11.0"
@@ -3009,21 +3104,21 @@ checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
 name = "litemap"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "litrs"
-version = "0.4.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5e54036fe321fd421e10d732f155734c4e4afd610dd556d9a82833ab3ee0bed"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "llvm-sys"
-version = "180.0.0"
+version = "211.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "778fa5fa02e32728e718f11eec147e6f134137399ab02fd2c13d32476337affa"
+checksum = "108b3ad2b2eaf2a561fc74196273b20e3436e4a688b8b44e250d83974dc1b2e2"
 dependencies = [
  "anyhow",
  "cc",
@@ -3069,7 +3164,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex-syntax",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3087,7 +3182,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4de4e09ccbef442225e81339e930ed93dc339d4f1b2eaf479f89590ebeb9bf13"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "loupe-derive",
  "rustversion",
 ]
@@ -3110,11 +3205,11 @@ checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.5"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
 dependencies = [
- "twox-hash 2.1.2",
+ "twox-hash",
 ]
 
 [[package]]
@@ -3127,6 +3222,16 @@ dependencies = [
  "crc",
 ]
 
+[[package]]
+name = "lzma-rust2"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c60a23ffb90d527e23192f1246b14746e2f7f071cb84476dd879071696c18a4a"
+dependencies = [
+ "crc",
+ "sha2",
+]
+
 [[package]]
 name = "lzma-sys"
 version = "0.1.20"
@@ -3157,6 +3262,12 @@ 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"
@@ -3174,7 +3285,7 @@ version = "6.1.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3189,14 +3300,20 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+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"
@@ -3215,9 +3332,9 @@ dependencies = [
 
 [[package]]
 name = "memmap2"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843a98750cd611cc2965a8213b53b43e715f13c37a9e096c6408e69990961db7"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
 dependencies = [
  "libc",
 ]
@@ -3294,30 +3411,30 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
 dependencies = [
  "libc",
  "log",
  "wasi 0.11.1+wasi-snapshot-preview1",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "miow"
-version = "0.3.7"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+checksum = "536bfad37a309d62069485248eeaba1e8d9853aaf951caaeaed0585a95346f08"
 dependencies = [
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "more-asserts"
-version = "0.2.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
+checksum = "1fafa6961cabd9c63bcd77a45d7e3b7f3b552b70417831fb0f56db717e72407e"
 
 [[package]]
 name = "multi-stash"
@@ -3342,7 +3459,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3381,7 +3498,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -3416,20 +3533,20 @@ 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.50.1"
+version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3459,9 +3576,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -3469,55 +3586,39 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
-[[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.30.4"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b4680b86d9cfafba8fc491dc9b6df26b68cf40e9e6cd73909194759a63c385"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
- "flate2",
  "memchr",
 ]
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "b8b28f24bd43920cd8e0bc4f9c6553e8b93221c512cb9a1014987fc89d36f830"
 dependencies = [
  "crc32fast",
  "flate2",
- "hashbrown 0.14.5",
- "indexmap 2.11.4",
+ "hashbrown 0.16.1",
+ "indexmap 2.12.1",
  "memchr",
  "ruzstd",
 ]
 
-[[package]]
-name = "object"
-version = "0.37.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -3526,9 +3627,9 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "once_cell_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "oorandom"
@@ -3538,22 +3639,22 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "opener"
-version = "0.6.1"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788"
+checksum = "cb9024962ab91e00c89d2a14352a8d0fc1a64346bf96f1839b45c09149564e47"
 dependencies = [
- "bstr 1.12.0",
+ "bstr 1.12.1",
  "normpath",
- "winapi",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "openssl"
-version = "0.10.73"
+version = "0.10.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
+checksum = "24ad14dd45412269e1a30f52ad8f0664f0f4f4a89ee8fe28c3b3527021ebb654"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -3570,7 +3671,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3581,9 +3682,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.109"
+version = "0.9.110"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571"
+checksum = "0a9f0075ba3c21b09f8e8b2026584b1d18d49388648f2fbbf3c97ea8deced8e2"
 dependencies = [
  "cc",
  "libc",
@@ -3591,6 +3692,12 @@ 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.5"
@@ -3612,7 +3719,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3718,7 +3825,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3733,52 +3840,55 @@ dependencies = [
 
 [[package]]
 name = "petgraph"
-version = "0.7.1"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
  "fixedbitset",
- "indexmap 2.11.4",
+ "hashbrown 0.15.5",
+ "indexmap 2.12.1",
+ "serde",
 ]
 
 [[package]]
 name = "phf"
-version = "0.11.3"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
 dependencies = [
  "phf_macros",
  "phf_shared",
+ "serde",
 ]
 
 [[package]]
 name = "phf_generator"
-version = "0.11.3"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
 dependencies = [
+ "fastrand",
  "phf_shared",
- "rand 0.8.5",
 ]
 
 [[package]]
 name = "phf_macros"
-version = "0.11.3"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
 dependencies = [
  "phf_generator",
  "phf_shared",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "phf_shared"
-version = "0.11.3"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
 dependencies = [
  "siphasher 1.0.1",
 ]
@@ -3800,7 +3910,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3827,34 +3937,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
-[[package]]
-name = "plotters"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
-dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "plotters-backend"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
-
-[[package]]
-name = "plotters-svg"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
-dependencies = [
- "plotters-backend",
-]
-
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -3863,9 +3945,9 @@ checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "potential_utf"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
 dependencies = [
  "zerovec",
 ]
@@ -3876,6 +3958,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
+[[package]]
+name = "ppmd-rust"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d558c559f0450f16f2a27a1f017ef38468c1090c9ce63c8e51366232d53717b4"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -3946,7 +4034,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3955,7 +4043,7 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "toml_edit 0.23.6",
+ "toml_edit",
 ]
 
 [[package]]
@@ -3977,14 +4065,14 @@ dependencies = [
  "proc-macro-error-attr2",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.101"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
@@ -3997,18 +4085,41 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
- "version_check",
- "yansi",
+ "syn 2.0.111",
+ "version_check",
+ "yansi",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
 ]
 
 [[package]]
-name = "ptr_meta"
-version = "0.1.4"
+name = "prost-types"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72"
 dependencies = [
- "ptr_meta_derive 0.1.4",
+ "prost",
 ]
 
 [[package]]
@@ -4017,18 +4128,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b9a0cf95a1196af61d4f1cbdab967179516d9a4a4312af1f31948f8f6224a79"
 dependencies = [
- "ptr_meta_derive 0.3.1",
-]
-
-[[package]]
-name = "ptr_meta_derive"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "ptr_meta_derive",
 ]
 
 [[package]]
@@ -4039,7 +4139,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4053,6 +4153,28 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "pulley-interpreter"
+version = "39.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a09eb45f768f3a0396e85822790d867000c8b5f11551e7268c279e991457b16"
+dependencies = [
+ "cranelift-bitset",
+ "log",
+ "pulley-macros",
+]
+
+[[package]]
+name = "pulley-macros"
+version = "39.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e29368432b8b7a8a343b75a6914621fad905c95d5c5297449a6546c127224f7a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -4070,9 +4192,9 @@ dependencies = [
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash 2.1.1",
+ "rustc-hash",
  "rustls",
- "socket2 0.6.0",
+ "socket2",
  "thiserror 2.0.17",
  "tokio",
  "tracing",
@@ -4086,11 +4208,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
 dependencies = [
  "bytes",
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "lru-slab",
  "rand 0.9.2",
  "ring",
- "rustc-hash 2.1.1",
+ "rustc-hash",
  "rustls",
  "rustls-pki-types",
  "slab",
@@ -4109,16 +4231,16 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.0",
+ "socket2",
  "tracing",
  "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.41"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 dependencies = [
  "proc-macro2",
 ]
@@ -4135,7 +4257,7 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a063ea72381527c2a0561da9c80000ef822bdd7c3241b1cc1b12100e3df081ee"
 dependencies = [
- "ptr_meta 0.3.1",
+ "ptr_meta",
 ]
 
 [[package]]
@@ -4194,7 +4316,7 @@ version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
 ]
 
 [[package]]
@@ -4223,7 +4345,7 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -4237,6 +4359,17 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.16",
+ "libredox",
+ "thiserror 2.0.17",
+]
+
 [[package]]
 name = "ref-cast"
 version = "1.0.25"
@@ -4254,31 +4387,32 @@ checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "regalloc2"
-version = "0.9.3"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
+checksum = "efd8138ce7c3d7c13be4f61893154b5d711bd798d2d7be3ecb8dcc7e7a06ca98"
 dependencies = [
- "hashbrown 0.13.2",
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.15.5",
  "log",
- "rustc-hash 1.1.0",
- "slice-group-by",
+ "rustc-hash",
  "smallvec",
 ]
 
 [[package]]
 name = "regex"
-version = "1.11.3"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
  "regex-syntax",
 ]
 
@@ -4290,9 +4424,9 @@ checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
 [[package]]
 name = "regex-automata"
-version = "0.4.11"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -4301,15 +4435,15 @@ dependencies = [
 
 [[package]]
 name = "regex-lite"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943f41321c63ef1c92fd763bfe054d2668f7f225a5c29f0105903dc2fc04ba30"
+checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.6"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "region"
@@ -4319,7 +4453,7 @@ checksum = "e6b6ebd13bc009aef9cd476c1310d49ac354d36e240cf1bd753290f3dc7199a7"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
- "mach2",
+ "mach2 0.4.3",
  "windows-sys 0.52.0",
 ]
 
@@ -4329,7 +4463,7 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cadadef317c2f20755a64d7fdc48f9e7178ee6b0e1f7fce33fa60f1d68a276e6"
 dependencies = [
- "bytecheck 0.8.2",
+ "bytecheck",
 ]
 
 [[package]]
@@ -4340,12 +4474,12 @@ checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884"
 
 [[package]]
 name = "reqwest"
-version = "0.12.23"
+version = "0.12.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb"
+checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
 dependencies = [
  "async-compression",
- "base64",
+ "base64 0.22.1",
  "bytes",
  "futures-channel",
  "futures-core",
@@ -4374,15 +4508,15 @@ dependencies = [
  "tokio-native-tls",
  "tokio-rustls",
  "tokio-util",
- "tower 0.5.2",
- "tower-http 0.6.6",
+ "tower",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots 1.0.2",
+ "webpki-roots 1.0.3",
 ]
 
 [[package]]
@@ -4405,12 +4539,12 @@ version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35a640b26f007713818e9a9b65d34da1cf58538207b052916a83d80e43f3ffa4"
 dependencies = [
- "bytecheck 0.8.2",
+ "bytecheck",
  "bytes",
  "hashbrown 0.15.5",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "munge",
- "ptr_meta 0.3.1",
+ "ptr_meta",
  "rancor",
  "rend",
  "rkyv_derive",
@@ -4426,7 +4560,7 @@ checksum = "bd83f5f173ff41e00337d97f6572e416d022ef8a19f371817259ae960324c482"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4463,12 +4597,6 @@ version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
 
-[[package]]
-name = "rustc-hash"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
-
 [[package]]
 name = "rustc-hash"
 version = "2.1.1"
@@ -4495,27 +4623,14 @@ dependencies = [
 
 [[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",
  "serde",
  "serde_json",
-]
-
-[[package]]
-name = "rustix"
-version = "0.38.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
-dependencies = [
- "bitflags 2.9.4",
- "errno",
- "libc",
- "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
+ "thiserror 1.0.69",
+ "tracing",
 ]
 
 [[package]]
@@ -4524,18 +4639,18 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "errno",
  "libc",
- "linux-raw-sys 0.11.0",
+ "linux-raw-sys",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.32"
+version = "0.23.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40"
+checksum = "6a9586e9ee2b4f8fab52a0048ca7334d7024eef48e2cb9407e3497bb7cab7fa7"
 dependencies = [
  "log",
  "once_cell",
@@ -4548,9 +4663,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
@@ -4560,9 +4675,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a"
 dependencies = [
  "web-time",
  "zeroize",
@@ -4570,9 +4685,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.7"
+version = "0.103.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf"
+checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -4630,13 +4745,11 @@ 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 0.99.20",
- "twox-hash 1.6.3",
+ "twox-hash",
 ]
 
 [[package]]
@@ -4664,6 +4777,15 @@ 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.28"
@@ -4675,12 +4797,13 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "0.8.22"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+checksum = "9558e172d4e8533736ba97870c4b2cd63f84b382a3d6eb063da41b91cce17289"
 dependencies = [
  "dyn-clone",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
+ "ref-cast",
  "schemars_derive",
  "serde",
  "serde_json",
@@ -4689,14 +4812,14 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.22"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+checksum = "301858a4023d78debd2353c7426dc486001bddc91ae31a76fb1f55132f7e2633"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4722,16 +4845,22 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
+[[package]]
+name = "sdd"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490dcfcbfef26be6800d11870ff2df8774fa6e86d047e3e8c8a76b25655e41ca"
+
 [[package]]
 name = "security-framework"
 version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
@@ -4744,7 +4873,7 @@ version = "3.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
@@ -4763,9 +4892,9 @@ dependencies = [
 
 [[package]]
 name = "self_cell"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
+checksum = "16c2f82143577edb4921b71ede051dac62ca3c16084e918bf7b40c96ae10eb33"
 
 [[package]]
 name = "semver"
@@ -4853,7 +4982,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4864,7 +4993,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4893,18 +5022,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_spanned"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee"
+checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
 dependencies = [
  "serde_core",
 ]
@@ -4927,7 +5047,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "itoa",
  "ryu",
  "serde",
@@ -4936,27 +5056,25 @@ dependencies = [
 
 [[package]]
 name = "serial_test"
-version = "2.0.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e56dd856803e253c8f298af3f4d7eb0ae5e23a737252cd90bb4f3b435033b2d"
+checksum = "1b258109f244e1d6891bf1053a55d63a5cd4f8f4c30cf9a1280989f80e7a1fa9"
 dependencies = [
- "dashmap 5.5.3",
- "futures",
- "lazy_static",
- "log",
+ "once_cell",
  "parking_lot",
+ "scc",
  "serial_test_derive",
 ]
 
 [[package]]
 name = "serial_test_derive"
-version = "2.0.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f"
+checksum = "5d69265a08751de7844521fd15003ae0a888e035773ba05695c5c759a6f89eef"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5057,12 +5175,6 @@ version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
-[[package]]
-name = "slice-group-by"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
-
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -5077,33 +5189,26 @@ 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.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "socket2"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -5114,9 +5219,9 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 
 [[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"
@@ -5155,9 +5260,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.106"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5181,7 +5286,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5203,15 +5308,15 @@ checksum = "422045212ea98508ae3d28025bc5aaa2bd4a9cdaecd442a08da2ee620ee9ea95"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
 
 [[package]]
 name = "target-triple"
-version = "0.1.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ac9aa371f599d22256307c24a9d748c041e548cbf599f35d890f9d365361790"
+checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b"
 
 [[package]]
 name = "tempfile"
@@ -5220,9 +5325,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
  "fastrand",
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "once_cell",
- "rustix 1.1.2",
+ "rustix",
  "windows-sys 0.61.2",
 ]
 
@@ -5248,12 +5353,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 0.38.44",
- "windows-sys 0.48.0",
+ "rustix",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -5276,14 +5381,14 @@ name = "test-generator"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
 ]
 
 [[package]]
 name = "test-log"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e33b98a582ea0be1168eba097538ee8dd4bbe0f2b01b22ac92ea30054e5be7b"
+checksum = "37d53ac171c92a39e4769491c4b4dde7022c60042254b5fc044ae409d34a24d4"
 dependencies = [
  "test-log-macros",
  "tracing-subscriber",
@@ -5291,13 +5396,13 @@ dependencies = [
 
 [[package]]
 name = "test-log-macros"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "451b374529930d7601b1eef8d32bc79ae870b6079b069401709c2a8bf9e75f36"
+checksum = "be35209fd0781c5401458ab66e4f98accf63553e8fae7425503e92fdd319783b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5348,7 +5453,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5359,7 +5464,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5415,9 +5520,9 @@ dependencies = [
 
 [[package]]
 name = "tinystr"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -5450,32 +5555,31 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.47.1"
+version = "1.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
 dependencies = [
- "backtrace",
  "bytes",
- "io-uring",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "slab",
- "socket2 0.6.0",
+ "socket2",
  "tokio-macros",
- "windows-sys 0.59.0",
+ "tracing",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5559,9 +5663,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.16"
+version = "0.7.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
 dependencies = [
  "bytes",
  "futures-core",
@@ -5572,36 +5676,14 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml"
-version = "0.8.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
-dependencies = [
- "indexmap 2.11.4",
- "serde",
- "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "toml_edit 0.22.27",
-]
-
-[[package]]
-name = "toml"
-version = "0.9.7"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0"
+checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "serde_core",
- "serde_spanned 1.0.2",
- "toml_datetime 0.7.2",
+ "serde_spanned",
+ "toml_datetime",
  "toml_parser",
  "toml_writer",
  "winnow",
@@ -5609,114 +5691,94 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.11"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1"
+checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.22.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
-dependencies = [
- "indexmap 2.11.4",
- "serde",
- "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "toml_write",
- "winnow",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.23.6"
+version = "0.23.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3effe7c0e86fdff4f69cdd2ccc1b96f933e24811c5441d44904e8683e27184b"
+checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
 dependencies = [
- "indexmap 2.11.4",
- "toml_datetime 0.7.2",
+ "indexmap 2.12.1",
+ "toml_datetime",
  "toml_parser",
  "winnow",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627"
+checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
 dependencies = [
  "winnow",
 ]
 
-[[package]]
-name = "toml_write"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
-
 [[package]]
 name = "toml_writer"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109"
+checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
 
 [[package]]
-name = "tower"
-version = "0.4.13"
+name = "tonic"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+checksum = "eb7613188ce9f7df5bfe185db26c5814347d110db17920415cf2fbcad85e7203"
 dependencies = [
- "futures-core",
- "futures-util",
+ "async-trait",
+ "axum",
+ "base64 0.22.1",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
  "pin-project",
- "pin-project-lite",
+ "socket2",
+ "sync_wrapper",
  "tokio",
+ "tokio-stream",
+ "tower",
  "tower-layer",
  "tower-service",
  "tracing",
 ]
 
 [[package]]
-name = "tower"
-version = "0.5.2"
+name = "tonic-prost"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+checksum = "66bd50ad6ce1252d87ef024b3d64fe4c3cf54a86fb9ef4c631fdd0ded7aeaa67"
 dependencies = [
- "futures-core",
- "futures-util",
- "pin-project-lite",
- "sync_wrapper",
- "tokio",
- "tower-layer",
- "tower-service",
+ "bytes",
+ "prost",
+ "tonic",
 ]
 
 [[package]]
-name = "tower-http"
+name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
 dependencies = [
- "bitflags 2.9.4",
- "bytes",
+ "futures-core",
  "futures-util",
- "http",
- "http-body",
- "http-body-util",
+ "indexmap 2.12.1",
  "pin-project-lite",
- "tower 0.4.13",
+ "slab",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -5724,20 +5786,22 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+checksum = "9cf146f99d442e8e68e585f5d798ccd3cad9a7835b917e09728880a862706456"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "bytes",
  "futures-util",
  "http",
  "http-body",
+ "http-body-util",
  "iri-string",
  "pin-project-lite",
- "tower 0.5.2",
+ "tower",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -5772,7 +5836,7 @@ checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5815,7 +5879,7 @@ dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex-automata 0.4.11",
+ "regex-automata 0.4.13",
  "serde",
  "serde_json",
  "sharded-slab",
@@ -5845,7 +5909,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
 dependencies = [
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5867,9 +5931,9 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "trybuild"
-version = "1.0.111"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ded9fdb81f30a5708920310bfcd9ea7482ff9cba5f54601f7a19a877d5c2392"
+checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335"
 dependencies = [
  "glob",
  "serde",
@@ -5877,7 +5941,7 @@ dependencies = [
  "serde_json",
  "target-triple",
  "termcolor",
- "toml 0.9.7",
+ "toml",
 ]
 
 [[package]]
@@ -5921,19 +5985,15 @@ dependencies = [
 
 [[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",
- "static_assertions",
-]
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
 
 [[package]]
-name = "twox-hash"
-version = "2.1.2"
+name = "typeid"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
 [[package]]
 name = "typenum"
@@ -5943,9 +6003,9 @@ 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",
@@ -5956,13 +6016,13 @@ 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.111",
 ]
 
 [[package]]
@@ -5979,9 +6039,9 @@ checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.19"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
+checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"
 
 [[package]]
 name = "unicode-normalization"
@@ -5998,12 +6058,6 @@ version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
-[[package]]
-name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-
 [[package]]
 name = "unicode-width"
 version = "0.2.2"
@@ -6018,132 +6072,141 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "uniffi"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb3a4c447c50fcda7bc5604a8588b7e1f37ffbfd8838a1516a290398efa7c6f0"
+checksum = "c866f627c3f04c3df068b68bb2d725492caaa539dd313e2a9d26bb85b1a32f4e"
 dependencies = [
  "anyhow",
+ "cargo_metadata 0.19.2",
+ "uniffi_bindgen",
  "uniffi_build",
  "uniffi_core",
  "uniffi_macros",
+ "uniffi_pipeline",
 ]
 
 [[package]]
 name = "uniffi_bindgen"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0be2bc6bafd82c979b0faca77c7b26630d54017de9f5bd5a686ec6ef038ad5d9"
+checksum = "7c8ca600167641ebe7c8ba9254af40492dda3397c528cc3b2f511bd23e8541a5"
 dependencies = [
  "anyhow",
  "askama",
  "camino",
- "cargo_metadata",
+ "cargo_metadata 0.19.2",
  "fs-err",
  "glob",
  "goblin",
- "heck 0.4.1",
+ "heck 0.5.0",
+ "indexmap 2.12.1",
  "once_cell",
- "paste",
  "serde",
+ "tempfile",
  "textwrap",
- "toml 0.5.11",
+ "toml",
+ "uniffi_internal_macros",
  "uniffi_meta",
- "uniffi_testing",
+ "uniffi_pipeline",
  "uniffi_udl",
 ]
 
 [[package]]
 name = "uniffi_build"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c59b65d59685ff3a10569287c6419f76487b4052ac52d5a0df38b2253d7f440"
+checksum = "3e55c05228f4858bb258f651d21d743fcc1fe5a2ec20d3c0f9daefddb105ee4d"
 dependencies = [
  "anyhow",
- "camino",
- "uniffi_bindgen",
-]
-
-[[package]]
-name = "uniffi_checksum_derive"
-version = "0.27.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5c400339a9d1d17be34257d0b407e91d64af335e5b4fa49f4bf28467fc8d635"
-dependencies = [
- "quote",
- "syn 2.0.106",
+ "camino",
+ "uniffi_bindgen",
 ]
 
 [[package]]
 name = "uniffi_core"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a02e67ac9634b10da9e4aa63a29a7920b8f1395eafef1ea659b2dd76dda96906"
+checksum = "7e7a5a038ebffe8f4cf91416b154ef3c2468b18e828b7009e01b1b99938089f9"
 dependencies = [
  "anyhow",
  "bytes",
- "camino",
- "log",
  "once_cell",
- "paste",
  "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 2.12.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.111",
+]
+
 [[package]]
 name = "uniffi_macros"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6f08d5592c669b80a8af5066027098bebec4b4af17a9b8b299bac5f518ab89e"
+checksum = "64c6309fc36c7992afc03bc0c5b059c656bccbef3f2a4bc362980017f8936141"
 dependencies = [
- "bincode",
  "camino",
  "fs-err",
  "once_cell",
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.106",
- "toml 0.5.11",
+ "syn 2.0.111",
+ "toml",
  "uniffi_meta",
 ]
 
 [[package]]
 name = "uniffi_meta"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "583bab49f2bdf5681f9732f8b67a7e555ad920dbb5427be21450217bf1818189"
+checksum = "0a138823392dba19b0aa494872689f97d0ee157de5852e2bec157ce6de9cdc22"
 dependencies = [
  "anyhow",
- "bytes",
  "siphasher 0.3.11",
- "uniffi_checksum_derive",
+ "uniffi_internal_macros",
+ "uniffi_pipeline",
 ]
 
 [[package]]
-name = "uniffi_testing"
-version = "0.27.3"
+name = "uniffi_pipeline"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13963044ca9bde9b709d2eee68bc11dafc7acea144ae0fdc0cf29ed4add44481"
+checksum = "8c27c4b515d25f8e53cc918e238c39a79c3144a40eaf2e51c4a7958973422c29"
 dependencies = [
  "anyhow",
- "camino",
- "cargo_metadata",
- "fs-err",
- "once_cell",
+ "heck 0.5.0",
+ "indexmap 2.12.1",
+ "tempfile",
+ "uniffi_internal_macros",
 ]
 
 [[package]]
 name = "uniffi_udl"
-version = "0.27.3"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b92f984bb0d9a06778f256aec963e1e9a80714014f7a90fb0e01008821fe5a97"
+checksum = "d0adacdd848aeed7af4f5af7d2f621d5e82531325d405e29463482becfdeafca"
 dependencies = [
  "anyhow",
  "textwrap",
  "uniffi_meta",
- "uniffi_testing",
  "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"
@@ -6164,18 +6227,31 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "ureq"
-version = "2.12.1"
+version = "3.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
+checksum = "d39cb1dbab692d82a977c0392ffac19e188bd9186a9f32806f0aaa859d75585a"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "flate2",
  "log",
- "once_cell",
+ "percent-encoding",
  "rustls",
  "rustls-pki-types",
- "url",
- "webpki-roots 0.26.11",
+ "ureq-proto",
+ "utf-8",
+ "webpki-roots 1.0.3",
+]
+
+[[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]]
@@ -6220,7 +6296,7 @@ version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "js-sys",
  "wasm-bindgen",
 ]
@@ -6250,14 +6326,14 @@ dependencies = [
  "anyhow",
  "async-trait",
  "bytes",
- "dashmap 6.1.0",
- "derive_more 2.0.1",
+ "dashmap",
+ "derive_more",
  "dunce",
  "filetime",
  "fs_extra",
  "futures",
  "getrandom 0.2.16",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "libc",
  "pin-project-lite",
  "pretty_assertions",
@@ -6266,7 +6342,7 @@ dependencies = [
  "shared-buffer",
  "slab",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "tracing",
  "tracing-test",
@@ -6285,9 +6361,10 @@ dependencies = [
  "bytes",
  "futures",
  "mio",
+ "parking",
  "serde",
- "socket2 0.5.10",
- "thiserror 1.0.69",
+ "socket2",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -6297,11 +6374,11 @@ version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64",
+ "base64 0.22.1",
  "bincode",
- "bytecheck 0.6.12",
+ "bytecheck",
  "bytes",
- "derive_more 2.0.1",
+ "derive_more",
  "futures-util",
  "hyper",
  "hyper-tungstenite",
@@ -6315,8 +6392,8 @@ dependencies = [
  "serde",
  "serial_test",
  "smoltcp",
- "socket2 0.5.10",
- "thiserror 1.0.69",
+ "socket2",
+ "thiserror 2.0.17",
  "tokio",
  "tokio-serde",
  "tokio-tungstenite 0.24.0",
@@ -6396,9 +6473,9 @@ version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "once_cell",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tracing",
  "wai-bindgen-wasmer-impl",
  "wasmer",
@@ -6475,15 +6552,6 @@ version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
-[[package]]
-name = "wasi"
-version = "0.14.7+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c"
-dependencies = [
- "wasip2",
-]
-
 [[package]]
 name = "wasi-test-generator"
 version = "6.1.0"
@@ -6493,7 +6561,7 @@ dependencies = [
  "serde",
  "serde_json",
  "tempfile",
- "wast 216.0.1",
+ "wast",
 ]
 
 [[package]]
@@ -6507,9 +6575,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.104"
+version = "0.2.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
+checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -6518,25 +6586,11 @@ dependencies = [
  "wasm-bindgen-shared",
 ]
 
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "wasm-bindgen-shared",
-]
-
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.54"
+version = "0.4.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
+checksum = "551f88106c6d5e7ccc7cd9a16f312dd3b5d36ea8b4954304657d5dfba115d4a0"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -6547,9 +6601,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.104"
+version = "0.2.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
+checksum = "04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -6557,31 +6611,31 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.104"
+version = "0.2.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
+checksum = "420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
- "wasm-bindgen-backend",
+ "syn 2.0.111",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.104"
+version = "0.2.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+checksum = "76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.54"
+version = "0.3.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e381134e148c1062f965a42ed1f5ee933eef2927c3f70d1812158f711d39865"
+checksum = "bfc379bfb624eb59050b509c13e77b4eb53150c350db69628141abce842f2373"
 dependencies = [
  "js-sys",
  "minicov",
@@ -6592,13 +6646,13 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.54"
+version = "0.3.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b673bca3298fe582aeef8352330ecbad91849f85090805582400850f8270a2e8"
+checksum = "085b2df989e1e6f9620c1311df6c996e83fe16f57792b272ce1e024ac16a90f1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -6648,41 +6702,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.216.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1de2d0fd411c201b8d76c04213901f9bb221abf17dd59c2201542d0b118bb90"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wasm-encoder"
-version = "0.221.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5"
-dependencies = [
- "leb128",
- "wasmparser 0.221.3",
-]
-
-[[package]]
-name = "wasm-encoder"
-version = "0.235.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3bc393c395cb621367ff02d854179882b9a351b4e0c93d1397e6090b53a5c2a"
-dependencies = [
- "leb128fmt",
- "wasmparser 0.235.0",
-]
-
-[[package]]
-name = "wasm-encoder"
-version = "0.239.0"
+version = "0.242.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be00faa2b4950c76fe618c409d2c3ea5a3c9422013e079482d78544bb2d184c"
+checksum = "67f90e55bc9c6ee6954a757cc6eb3424d96b442e5252ed10fea627e518878d36"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.239.0",
+ "wasmparser 0.242.0",
 ]
 
 [[package]]
@@ -6719,9 +6744,11 @@ dependencies = [
  "bytes",
  "cfg-if",
  "cmake",
- "derive_more 2.0.1",
- "hashbrown 0.11.2",
- "indexmap 2.11.4",
+ "corosensei",
+ "derive_more",
+ "futures",
+ "hashbrown 0.16.1",
+ "indexmap 2.12.1",
  "js-sys",
  "loupe",
  "macro-wasmer-universal-test",
@@ -6733,9 +6760,10 @@ dependencies = [
  "serde-wasm-bindgen",
  "shared-buffer",
  "tar",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
+ "tokio",
  "tracing",
  "ureq",
  "wasm-bindgen",
@@ -6751,7 +6779,7 @@ dependencies = [
  "wasmparser 0.224.1",
  "wat",
  "which",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
  "xz",
  "zip",
 ]
@@ -6764,7 +6792,7 @@ dependencies = [
  "async-trait",
  "clap",
  "cynic",
- "derive_more 2.0.1",
+ "derive_more",
  "futures",
  "indicatif",
  "log",
@@ -6787,7 +6815,7 @@ version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-tungstenite",
- "base64",
+ "base64 0.22.1",
  "cynic",
  "futures",
  "getrandom 0.2.16",
@@ -6837,7 +6865,7 @@ dependencies = [
  "inline-c",
  "libc",
  "paste",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -6861,7 +6889,7 @@ version = "6.1.0"
 dependencies = [
  "cc",
  "regex",
- "target-lexicon 0.11.2",
+ "target-lexicon 0.13.3",
  "walkdir",
 ]
 
@@ -6876,9 +6904,9 @@ dependencies = [
  "clap_lex",
  "criterion",
  "hex",
- "rand 0.8.5",
+ "rand 0.9.2",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "wasmer",
  "wasmer-compiler-singlepass",
 ]
@@ -6889,7 +6917,7 @@ version = "6.1.0"
 dependencies = [
  "cc",
  "regex",
- "target-lexicon 0.11.2",
+ "target-lexicon 0.13.3",
  "walkdir",
 ]
 
@@ -6898,20 +6926,21 @@ name = "wasmer-cli"
 version = "6.1.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.17",
+ "assert_cmd 2.1.1",
  "async-trait",
- "base64",
+ "base64 0.22.1",
  "bytes",
  "bytesize",
- "cargo_metadata",
+ "cargo_metadata 0.23.1",
  "cfg-if",
  "chrono",
  "clap",
  "clap_complete",
  "clap_mangen",
- "colored 2.2.0",
+ "colored",
  "comfy-table",
- "console",
+ "console 0.16.1",
+ "console-subscriber",
  "dialoguer",
  "dirs",
  "dotenvy",
@@ -6919,26 +6948,27 @@ dependencies = [
  "fuser",
  "futures",
  "futures-util",
+ "git-version",
  "hex",
  "http",
  "http-body-util",
  "humantime",
  "hyper",
  "hyper-util",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "indicatif",
  "interfaces",
- "is-terminal",
  "libc",
  "log",
  "lzma-rs",
  "mac_address",
  "mio",
  "normpath",
- "object 0.32.2",
+ "object 0.38.0",
  "once_cell",
  "opener",
  "parking_lot",
+ "path-clean",
  "pathdiff",
  "predicates 3.1.3",
  "pretty_assertions",
@@ -6952,14 +6982,14 @@ dependencies = [
  "sha2",
  "shared-buffer",
  "tar",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "time 0.1.45",
  "time 0.3.44",
  "tokio",
  "tokio-tungstenite 0.24.0",
- "toml 0.8.23",
+ "toml",
  "tracing",
  "tracing-subscriber",
  "unix_mode",
@@ -6996,14 +7026,15 @@ dependencies = [
  "cfg-if",
  "enum-iterator",
  "enumset",
- "hashbrown 0.11.2",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
  "leb128",
  "libc",
  "loupe",
  "macho-unwind-info",
- "memmap2 0.6.2",
+ "memmap2 0.9.9",
  "more-asserts",
- "object 0.32.2",
+ "object 0.38.0",
  "region",
  "rkyv",
  "self_cell",
@@ -7011,37 +7042,17 @@ dependencies = [
  "serde_bytes",
  "shared-buffer",
  "smallvec",
- "target-lexicon 0.12.16",
- "thiserror 1.0.69",
+ "target-lexicon 0.13.3",
+ "tempfile",
+ "thiserror 2.0.17",
  "wasmer-types",
  "wasmer-vm",
  "wasmparser 0.224.1",
- "windows-sys 0.59.0",
+ "which",
+ "windows-sys 0.61.2",
  "xxhash-rust",
 ]
 
-[[package]]
-name = "wasmer-compiler-cli"
-version = "6.1.0"
-dependencies = [
- "anyhow",
- "bytesize",
- "cfg-if",
- "clap",
- "colored 2.2.0",
- "distance",
- "fern",
- "is-terminal",
- "log",
- "target-lexicon 0.12.16",
- "unix_mode",
- "wasmer-compiler",
- "wasmer-compiler-cranelift",
- "wasmer-compiler-llvm",
- "wasmer-compiler-singlepass",
- "wasmer-types",
-]
-
 [[package]]
 name = "wasmer-compiler-cranelift"
 version = "6.1.0"
@@ -7049,13 +7060,13 @@ dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
  "cranelift-frontend",
- "gimli 0.28.1",
- "hashbrown 0.11.2",
- "itertools 0.12.1",
+ "gimli",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
  "more-asserts",
  "rayon",
  "smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
  "tracing",
  "wasmer-compiler",
  "wasmer-types",
@@ -7068,16 +7079,16 @@ dependencies = [
  "byteorder",
  "cc",
  "inkwell",
- "itertools 0.12.1",
+ "itertools 0.14.0",
  "libc",
- "object 0.32.2",
+ "object 0.38.0",
  "phf",
  "rayon",
  "regex",
  "rustc_version 0.4.1",
  "semver 1.0.27",
  "smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
  "tracing",
  "wasmer-compiler",
  "wasmer-types",
@@ -7092,12 +7103,14 @@ dependencies = [
  "dynasm",
  "dynasmrt",
  "enumset",
- "gimli 0.28.1",
- "hashbrown 0.11.2",
+ "gimli",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
  "more-asserts",
  "rayon",
  "smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
+ "tempfile",
  "wasmer-compiler",
  "wasmer-types",
 ]
@@ -7111,7 +7124,7 @@ dependencies = [
  "ciborium",
  "derive_builder",
  "hex",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "pretty_assertions",
  "saffron",
  "schemars",
@@ -7120,8 +7133,8 @@ dependencies = [
  "serde_json",
  "serde_yaml",
  "tempfile",
- "thiserror 1.0.69",
- "toml 0.8.23",
+ "thiserror 2.0.17",
+ "toml",
  "url",
 ]
 
@@ -7133,7 +7146,7 @@ dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.111",
  "wasmer-types",
 ]
 
@@ -7170,7 +7183,7 @@ name = "wasmer-integration-tests-cli"
 version = "6.1.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.17",
+ "assert_cmd 2.1.1",
  "dirs",
  "flate2",
  "futures",
@@ -7178,16 +7191,16 @@ dependencies = [
  "insta",
  "libc",
  "md5",
- "object 0.30.4",
+ "object 0.38.0",
  "once_cell",
- "predicates 2.1.5",
+ "predicates 3.1.3",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.2",
  "regex",
  "reqwest",
  "serde",
  "tar",
- "target-lexicon 0.12.16",
+ "target-lexicon 0.13.3",
  "tempfile",
  "tokio",
 ]
@@ -7202,11 +7215,11 @@ version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64",
+ "base64 0.22.1",
  "bincode",
- "bytecheck 0.6.12",
+ "bytecheck",
  "bytes",
- "derive_more 2.0.1",
+ "derive_more",
  "lz4_flex",
  "num_enum",
  "rkyv",
@@ -7214,7 +7227,7 @@ dependencies = [
  "serde_json",
  "shared-buffer",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tracing",
  "tracing-test",
  "virtual-fs",
@@ -7255,8 +7268,8 @@ dependencies = [
  "shared-buffer",
  "tar",
  "tempfile",
- "thiserror 1.0.69",
- "toml 0.8.23",
+ "thiserror 2.0.17",
+ "toml",
  "ureq",
  "url",
  "wasmer-config",
@@ -7280,9 +7293,9 @@ dependencies = [
  "serde_yaml",
  "sha2",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
- "toml 0.8.23",
+ "toml",
  "tracing",
  "url",
  "walkdir",
@@ -7296,7 +7309,7 @@ dependencies = [
 name = "wasmer-swift"
 version = "0.601.0"
 dependencies = [
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "uniffi",
  "virtual-fs",
@@ -7324,12 +7337,12 @@ dependencies = [
 name = "wasmer-types"
 version = "6.1.0"
 dependencies = [
- "bytecheck 0.6.12",
+ "bytecheck",
  "enum-iterator",
  "enumset",
  "getrandom 0.2.16",
  "hex",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "loupe",
  "memoffset 0.9.1",
  "more-asserts",
@@ -7337,8 +7350,8 @@ dependencies = [
  "serde",
  "serde_bytes",
  "sha2",
- "target-lexicon 0.12.16",
- "thiserror 1.0.69",
+ "target-lexicon 0.13.3",
+ "thiserror 2.0.17",
  "wasmparser 0.224.1",
  "xxhash-rust",
 ]
@@ -7352,24 +7365,25 @@ dependencies = [
  "cfg-if",
  "corosensei",
  "crossbeam-queue",
- "dashmap 6.1.0",
+ "dashmap",
  "enum-iterator",
  "fnv",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "libc",
  "libunwind",
  "loupe",
- "mach2",
+ "mach2 0.6.0",
  "memoffset 0.9.1",
  "more-asserts",
+ "parking_lot",
  "region",
  "rustversion",
  "scopeguard",
  "serde",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tracing",
  "wasmer-types",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7379,22 +7393,22 @@ dependencies = [
  "anyhow",
  "assert-panic",
  "async-trait",
- "base64",
+ "base64 0.22.1",
  "bincode",
  "blake3",
  "bus",
- "bytecheck 0.6.12",
+ "bytecheck",
  "bytes",
  "cfg-if",
  "chrono",
  "cooked-waker",
  "crossbeam-channel",
- "dashmap 6.1.0",
- "derive_more 2.0.1",
+ "dashmap",
+ "derive_more",
  "env_logger",
  "futures",
  "getrandom 0.2.16",
- "heapless",
+ "heapless 0.9.2",
  "hex",
  "http",
  "http-body-util",
@@ -7426,12 +7440,12 @@ dependencies = [
  "tempfile",
  "terminal_size",
  "termios",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "tokio-stream",
- "toml 0.8.23",
- "tower 0.4.13",
- "tower-http 0.5.2",
+ "toml",
+ "tower",
+ "tower-http",
  "tracing",
  "tracing-subscriber",
  "tracing-test",
@@ -7446,7 +7460,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
- "wasm-encoder 0.235.0",
+ "wasm-encoder 0.242.0",
  "wasmer",
  "wasmer-config",
  "wasmer-journal",
@@ -7459,7 +7473,7 @@ dependencies = [
  "web-sys",
  "webc",
  "weezl",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
  "xxhash-rust",
 ]
 
@@ -7468,7 +7482,7 @@ name = "wasmer-wasix-types"
 version = "0.601.0"
 dependencies = [
  "anyhow",
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "byteorder",
  "cfg-if",
  "num_enum",
@@ -7491,16 +7505,17 @@ name = "wasmer-wast"
 version = "6.1.0"
 dependencies = [
  "anyhow",
+ "fs_extra",
  "futures",
  "serde",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "virtual-fs",
  "wasmer",
  "wasmer-types",
  "wasmer-wasix",
- "wast 221.0.3",
+ "wast",
 ]
 
 [[package]]
@@ -7518,6 +7533,7 @@ dependencies = [
  "criterion",
  "crossbeam-queue",
  "glob",
+ "itertools 0.14.0",
  "reqwest",
  "rustc_version 0.4.1",
  "serial_test",
@@ -7528,7 +7544,6 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "ureq",
- "wasi-test-generator",
  "wasmer",
  "wasmer-cache",
  "wasmer-compiler",
@@ -7602,26 +7617,13 @@ dependencies = [
  "wasmi_core",
 ]
 
-[[package]]
-name = "wasmparser"
-version = "0.121.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
-dependencies = [
- "bitflags 2.9.4",
- "indexmap 2.11.4",
- "semver 1.0.27",
-]
-
 [[package]]
 name = "wasmparser"
 version = "0.221.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
 dependencies = [
- "bitflags 2.9.4",
- "indexmap 2.11.4",
- "semver 1.0.27",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -7630,86 +7632,60 @@ version = "0.224.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04f17a5917c2ddd3819e84c661fae0d6ba29d7b9c1f0e96c708c65a9c4188e11"
 dependencies = [
- "bitflags 2.9.4",
-]
-
-[[package]]
-name = "wasmparser"
-version = "0.235.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "161296c618fa2d63f6ed5fffd1112937e803cb9ec71b32b01a76321555660917"
-dependencies = [
- "bitflags 2.9.4",
- "indexmap 2.11.4",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
 name = "wasmparser"
-version = "0.239.0"
+version = "0.242.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9d90bb93e764f6beabf1d02028c70a2156a6583e63ac4218dd07ef733368b0"
+checksum = "ed3c6e611f4cd748d85c767815823b777dc56afca793fcda27beae4e85028849"
 dependencies = [
- "bitflags 2.9.4",
- "indexmap 2.11.4",
+ "bitflags 2.10.0",
+ "indexmap 2.12.1",
  "semver 1.0.27",
 ]
 
 [[package]]
 name = "wasmprinter"
-version = "0.2.80"
+version = "0.242.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60e73986a6b7fdfedb7c5bf9e7eb71135486507c8fbc4c0c42cffcb6532988b7"
+checksum = "936a79bf33649f3aa0cd7cdf495e62ac0c718b3630ab53946df6dc2eff73a0d6"
 dependencies = [
  "anyhow",
- "wasmparser 0.121.2",
-]
-
-[[package]]
-name = "wast"
-version = "216.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62cc4cc72b93d4a11c416ad1b4bb37888a9ea1dff575ee865f5bf26682ceba0e"
-dependencies = [
- "bumpalo",
- "leb128",
- "memchr",
- "unicode-width 0.1.14",
- "wasm-encoder 0.216.1",
+ "termcolor",
+ "wasmparser 0.242.0",
 ]
 
 [[package]]
-name = "wast"
-version = "221.0.3"
+name = "wasmtime-internal-math"
+version = "39.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e0d10d282261b825ffb3d49f46e8309e60a8b608328b6a0b0578e80f3f98e57"
+checksum = "cd1b856e1bbf0230ab560ba4204e944b141971adc4e6cdf3feb6979c1a7b7953"
 dependencies = [
- "bumpalo",
- "leb128",
- "memchr",
- "unicode-width 0.2.2",
- "wasm-encoder 0.221.3",
+ "libm",
 ]
 
 [[package]]
 name = "wast"
-version = "239.0.0"
+version = "242.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9139176fe8a2590e0fb174cdcaf373b224cb93c3dde08e4297c1361d2ba1ea5d"
+checksum = "50a61ae2997784a4ae2a47b3a99f7cf0ad2a54db09624a28a0c2e9d7a24408ce"
 dependencies = [
  "bumpalo",
  "leb128fmt",
  "memchr",
- "unicode-width 0.2.2",
- "wasm-encoder 0.239.0",
+ "unicode-width",
+ "wasm-encoder 0.242.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.239.0"
+version = "1.242.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e1c941927d34709f255558166f8901a2005f8ab4a9650432e9281b7cc6f3b75"
+checksum = "5ae8cf6adfb79b5d89cb3fe68bd56aaab9409d9cf23b588097eae7d75585dae2"
 dependencies = [
- "wast 239.0.0",
+ "wast",
 ]
 
 [[package]]
@@ -7739,9 +7715,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.81"
+version = "0.3.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
+checksum = "3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -7764,13 +7740,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "637506ca3c48eae3301e97f0167aa1b46cdfdd479d008b868a19715182e48ae3"
 dependencies = [
  "anyhow",
- "base64",
+ "base64 0.22.1",
  "bytes",
  "cfg-if",
  "ciborium",
  "document-features",
  "ignore",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "leb128",
  "lexical-sort",
  "libc",
@@ -7791,14 +7767,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.2",
+ "webpki-roots 1.0.3",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2"
+checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -7814,19 +7790,18 @@ dependencies = [
 
 [[package]]
 name = "weezl"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
 [[package]]
 name = "which"
-version = "7.0.3"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
+checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d"
 dependencies = [
- "either",
  "env_home",
- "rustix 1.1.2",
+ "rustix",
  "winsafe",
 ]
 
@@ -7882,7 +7857,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -7893,7 +7868,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -7920,15 +7895,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -7965,21 +7931,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-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",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -8013,12 +7964,6 @@ dependencies = [
  "windows_x86_64_msvc 0.53.1",
 ]
 
-[[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_gnullvm"
 version = "0.52.6"
@@ -8031,12 +7976,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -8049,12 +7988,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 
-[[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_gnu"
 version = "0.52.6"
@@ -8079,12 +8012,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -8097,12 +8024,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
-[[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_gnu"
 version = "0.52.6"
@@ -8115,12 +8036,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -8133,12 +8048,6 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
@@ -8174,9 +8083,9 @@ checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
 name = "writeable"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
 [[package]]
 name = "xattr"
@@ -8185,7 +8094,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
 dependencies = [
  "libc",
- "rustix 1.1.2",
+ "rustix",
 ]
 
 [[package]]
@@ -8220,11 +8129,10 @@ checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "yoke"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
 dependencies = [
- "serde",
  "stable_deref_trait",
  "yoke-derive",
  "zerofrom",
@@ -8232,13 +8140,13 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
  "synstructure",
 ]
 
@@ -8269,7 +8177,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -8280,7 +8188,7 @@ checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -8300,7 +8208,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
  "synstructure",
 ]
 
@@ -8321,14 +8229,14 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "zerotrie"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
 dependencies = [
  "displaydoc",
  "yoke",
@@ -8337,9 +8245,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.4"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -8348,45 +8256,48 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "zip"
-version = "2.4.2"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
+checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
 dependencies = [
  "aes",
  "arbitrary",
  "bzip2",
  "constant_time_eq",
  "crc32fast",
- "crossbeam-utils",
  "deflate64",
- "displaydoc",
  "flate2",
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "hmac",
- "indexmap 2.11.4",
- "lzma-rs",
+ "indexmap 2.12.1",
+ "lzma-rust2",
  "memchr",
  "pbkdf2",
+ "ppmd-rust",
  "sha1",
- "thiserror 2.0.17",
  "time 0.3.44",
- "xz2",
  "zeroize",
  "zopfli",
  "zstd",
 ]
 
+[[package]]
+name = "zlib-rs"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f06ae92f42f5e5c42443fd094f245eb656abf56dd7cce9b8b263236565e00f2"
+
 [[package]]
 name = "zopfli"
 version = "0.8.2"
diff --git a/Cargo.toml b/Cargo.toml
index 1a866eac9f..ed71d86dca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,29 +13,26 @@ version.workspace = true
 
 [dependencies]
 wasmer = { version = "=6.1.0", path = "lib/api", default-features = false }
+wasmer-cache = { version = "=6.1.0", path = "lib/cache", optional = true }
 wasmer-compiler = { version = "=6.1.0", path = "lib/compiler", features = [
 	"compiler",
 ], optional = true }
 wasmer-compiler-cranelift = { version = "=6.1.0", path = "lib/compiler-cranelift", optional = true }
-wasmer-compiler-singlepass = { version = "=6.1.0", path = "lib/compiler-singlepass", optional = true }
 wasmer-compiler-llvm = { version = "=6.1.0", path = "lib/compiler-llvm", optional = true }
-wasmer-wasix = { path = "lib/wasix", optional = true }
-wasmer-wast = { version = "=6.1.0", path = "tests/lib/wast", optional = true }
-wasi-test-generator = { version = "=6.1.0", path = "tests/wasi-wast", optional = true }
-wasmer-cache = { version = "=6.1.0", path = "lib/cache", optional = true }
-wasmer-types = { version = "=6.1.0", path = "lib/types" }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "lib/compiler-singlepass", optional = true }
 wasmer-middlewares = { version = "=6.1.0", path = "lib/middlewares", optional = true }
-
+wasmer-types = { version = "=6.1.0", path = "lib/types" }
+wasmer-wast = { version = "=6.1.0", path = "tests/lib/wast", optional = true }
+wasmer-wasix = { path = "lib/wasix", optional = true }
 
 # Third party dependencies
-
-cfg-if = "1.0"
-tokio = { version = "1.39", features = [
+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 = [
@@ -47,7 +44,6 @@ members = [
 	"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",
@@ -74,18 +70,17 @@ members = [
 	"tests/lib/wast",
 	"tests/wasi-wast",
 	"tests/wasmer-argus",
-	"lib/sdk",
 ]
 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.84"
+rust-version = "1.90"
 version = "6.1.0"
 
 [workspace.dependencies]
@@ -101,84 +96,239 @@ shared-buffer = "0.1.4"
 loupe = "0.2.0"
 
 # Third-party crates
-bytes = "1"
-serde_bytes = { version = "0.11" }
-hex = "0.4"
 anyhow = "1.0"
-sha2 = "0.10"
+assert-panic = "1.0.1"
+assert_cmd = "2.1.1"
 async-trait = "0.1.68"
-getrandom = "0.2"
-ciborium = "0.2.2"
-bytesize = "1.3.0"
-semver = "1.0"
-tempfile = "3.6.0"
+async-tungstenite = "0.28.0"
+axum = { version = "=0.6.9", default-features = false }
+backtrace = "0.3"
+base64 = "0.22.1"
+bincode = "1.3"
+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"
-tar = "0.4.40"
+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.126.1", default-features = false }
+cranelift-entity = { version = "=0.126.1", default-features = false }
+cranelift-frontend = { version = "=0.126.1", default-features = false }
+criterion = { version = "0.7", 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"
+env_logger = { version = "0.11.5", default-features = false }
+field-offset = "0.3.3"
+filetime = "0.2.18"
 flate2 = "1.0.34"
+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.11.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.13"
+hyper-util = "0.1.5"
+ignore = "0.4"
+indicatif = "0.18.3"
+indexmap = "2"
+inline-c = "0.1.7"
+# TODO: use a proper release
+inkwell = { git = "https://github.com/TheDan64/inkwell.git", rev = "b9c53276e30935ccec841d12c9687a17e9199958", default-features = false }
+insta = "1.44.2"
+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"
-blake3 = "1.0"
+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"
 rayon = "1.7.0"
-itertools = "0.12"
-byteorder = "1.3"
-more-asserts = "0.2"
-enum-iterator = "0.7.0"
-backtrace = "0.3"
-hashbrown = "0.11"
-smallvec = "1.6"
+regex = "1.11"
 region = "3.0"
-once_cell = "1.17.1"
-num_enum = "0.7.3"
-dashmap = "6.0.1"
-http = "1.0.0"
-hyper = "1"
-hyper-util = "0.1.5"
-http-body-util = "0.1.1"
+replace_with = "0.1.7"
 reqwest = { version = "0.12.0", default-features = false }
-enumset = "1.1.0"
-memoffset = "0.9.0"
-wasmparser = { version = "0.224.0", default-features = false, features = [
-	"validate",
-	"features",
-	"simd",
-] }
 rkyv = { version = "0.8.8", features = ["indexmap-2", "bytes-1"] }
-memmap2 = { version = "0.6.2" }
-toml = { version = "0.8", features = ["preserve_order"] }
-indexmap = "2"
+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_yaml = { version = "0.9.34" }
+serde-wasm-bindgen = "0.6.5"
+serde_bytes = { version = "0.11" }
+serde_derive = "^1"
 serde_json = { version = "1" }
-bytecheck = { version = "0.6.8" }
-libc = { version = "^0.2", default-features = false }
-gimli = { version = "0.28.1" }
-futures-util = { version = "0.3.31" }
-mio = "1"
+serde_path_to_error = "0.1.14"
+serde_yaml = { version = "0.9.34" }
+serial_test = { version = "3.2.0", default-features = false }
+sha2 = "0.10"
+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.24.0" }
-tracing = { version = "0.1" }
-tracing-subscriber = { version = "0.3" }
+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" }
-socket2 = { version = "0.5.7", features = ["all"] }
-pretty_assertions = "1.4.0"
-base64 = "0.22.0"
-time = "0.3.36"
+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"
-thiserror = "1"
-target-lexicon = { version = "0.12.2", default-features = false }
-object = { version = "0.32.0", default-features = true }
-derive_more = { version = "2.0.1", features = ["debug", "display"] }
-wasm-encoder = { version = "0.235.0", default-features = false, features = [
+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.1.11"
+wasm-encoder = { version = "0.242.0", default-features = false, features = [
 	"std",
 ] }
-ignore = "0.4"
+wasm-smith = "0.4.4"
+wasmi_c_api_impl = "0.40.0"
+wasmparser = { version = "0.224.0", default-features = false, features = [
+	"validate",
+	"features",
+	"simd",
+] }
+wasmprinter = "0.242.0"
+wasmer-inline-c = "0.1.1"
+wast = "242.0.0"
+wat = "1.242.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 = "6.0.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 = "=6.1.0", path = "lib/api", features = [
@@ -186,24 +336,25 @@ wasmer = { version = "=6.1.0", path = "lib/api", features = [
 	"singlepass",
 	"sys",
 ] }
-anyhow = "1.0"
-criterion = { version = "0.5", features = ["csv_output"] }
-clap = { version = "=4.4.11" }
-clap_builder = { version = "=4.4.11" }
-clap_derive = { version = "=4.4.7" }
-clap_lex = { version = "=0.6.0" }
-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 = [
+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
@@ -238,6 +389,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"]
@@ -444,3 +596,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 d2a25bf881..1f06fd9aff 100644
--- a/Makefile
+++ b/Makefile
@@ -155,25 +155,25 @@ 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-18 2>/dev/null))
-	LLVM_VERSION := $(shell llvm-config-18 --version)
+else ifneq (, $(shell which llvm-config-21 2>/dev/null))
+	LLVM_VERSION := $(shell llvm-config-21 --version)
 	compilers += llvm
-	# need force LLVM_SYS_180_PREFIX, or llvm_sys will not build in the case
-	export LLVM_SYS_180_PREFIX = $(shell llvm-config-18 --prefix)
+	# 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 18,$(LLVM_VERSION)))
+	ifneq (, $(findstring 21,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_180_PREFIX = $(shell llvm-config --prefix)
-	else ifneq (, $(findstring 18,$(LLVM_VERSION)))
+		export LLVM_SYS_211_PREFIX = $(shell llvm-config --prefix)
+	else ifneq (, $(findstring 21,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_180_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
@@ -371,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 -----------)
@@ -380,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:)
@@ -401,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 )
@@ -437,13 +437,13 @@ 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-wasip1 --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  \
@@ -468,14 +468,12 @@ 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-wasip1 --features singlepass,cranelift --bin wasmer-compiler --locked
-
 # For best results ensure the release profile looks like the following
 # in Cargo.toml:
 # [profile.release]
@@ -500,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 --exclude wasmer-swift --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
@@ -547,10 +545,10 @@ test-build-docs-rs-ci:
 		fi; \
 		printf "*** Building doc for package with manifest $$manifest_path and features $$features ***\n\n"; \
 		if [ -z "$$features" ]; then \
-			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2025-02-09 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-2025-02-09 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
 
@@ -629,19 +627,19 @@ build-capi-headless-ios:
 
 # test compilers
 test-stage-0-wast:
-	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked --jobs=1
+	$(CARGO_BINARY) nextest run $(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 --jobs=1
-	$(CARGO_BINARY) test --doc $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked --jobs=1
+	$(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:
@@ -650,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
 
@@ -687,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
 
@@ -716,6 +717,9 @@ 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
@@ -730,6 +734,10 @@ 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
@@ -765,7 +773,7 @@ test-integration-cli-wamr-ci: require-nextest build-wasmer-wamr
 	rustup target add wasm32-wasip1
 	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --features webc_runner,wamr -p wasmer-integration-tests-cli --locked --no-fail-fast -E "not (test(deploy) | test(snapshot) | test(login) | test(init) | test(gen_c_header) | test(up_to_date) | test(publish) | test(create) | test(whoami) | test(config) | test(c_flags))"
 
-test-integration-cli-wasmi-ci: require-nextest build-wasmer-wasmi
+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))"
 
@@ -1050,16 +1058,33 @@ update-testsuite:
 
 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 --exclude wasmer-swift --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
 
diff --git a/README.md b/README.md
index fef44a0f19..e917572ebc 100644
--- a/README.md
+++ b/README.md
@@ -142,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]                  |                        |
@@ -202,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
@@ -263,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/benches/compile.rs b/benches/compile.rs
index 6ce896a57a..f1642691d4 100644
--- a/benches/compile.rs
+++ b/benches/compile.rs
@@ -1,5 +1,5 @@
 use criterion::{
-    criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion,
+    BenchmarkGroup, Criterion, criterion_group, criterion_main, measurement::WallTime,
 };
 use wasmer::*;
 
diff --git a/benches/deserialize_modules.rs b/benches/deserialize_modules.rs
index 10207a7723..789a2fe8ad 100644
--- a/benches/deserialize_modules.rs
+++ b/benches/deserialize_modules.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 
 use wasmer::*;
 
diff --git a/benches/import_functions.rs b/benches/import_functions.rs
index 23fafc44c1..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::*;
 
diff --git a/benches/run.rs b/benches/run.rs
index d83eeff64c..a4ff0a3462 100644
--- a/benches/run.rs
+++ b/benches/run.rs
@@ -1,18 +1,18 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-use wasmer::{sys::*, *};
+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 LLVM::new().into();
+    return wasmer_compiler_llvm::LLVM::new().into();
 
     #[cfg(feature = "singlepass")]
-    return Singlepass::new().into();
+    return wasmer_compiler_singlepass::Singlepass::new().into();
 
     #[cfg(feature = "cranelift")]
-    return Cranelift::new().into();
+    return wasmer_compiler_cranelift::Cranelift::new().into();
 
     #[cfg(not(any(feature = "cranelift", feature = "llvm", feature = "singlepass")))]
     return Default::default();
diff --git a/benches/static_and_dynamic_functions.rs b/benches/static_and_dynamic_functions.rs
index ab2d17b171..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::*;
 
@@ -50,31 +52,29 @@ 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}"),
         |b| {
diff --git a/build.rs b/build.rs
index 5028469735..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/*")
diff --git a/deny.toml b/deny.toml
index 293f8df2aa..8769a1b707 100644
--- a/deny.toml
+++ b/deny.toml
@@ -101,15 +101,14 @@ allow = [
 	"MPL-2.0",
 	"0BSD",
 	"CC0-1.0",
-	"OpenSSL",
 	"BSD-3-Clause",
-	"Unicode-DFS-2016",
-	"Unicode-3.0",
 	# BOOST source license
 	# NOTE: not to be confused with business source license!
 	"BSL-1.0",
 	"Unicode-3.0",
 	"CDLA-Permissive-2.0",
+	"Zlib",
+	"bzip2-1.0.6"
 ]
 # The confidence threshold for detecting a license from license text.
 # The higher the value, the more closely the license text must be to the
@@ -130,7 +129,20 @@ exceptions = [
 # 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]]
+[[licenses.clarify]]
+crate = "wasmer-compiler-singlepass"
+expression = "BUSL-1.1"
+license-files = [
+    { path = "LICENSE", hash = 0x11303e40 },
+]
+
+[[licenses.clarify]]
+crate = "wasmer-compiler-llvm"
+expression = "BUSL-1.1"
+license-files = [
+    { path = "LICENSE", hash = 0x79b6d01b },
+]
+
 # The package spec the clarification applies to
 #crate = "ring"
 # The SPDX expression for the license requirements of the crate
diff --git a/docs/ATTRIBUTIONS.md b/docs/ATTRIBUTIONS.md
index c322f14091..0bae77e815 100644
--- a/docs/ATTRIBUTIONS.md
+++ b/docs/ATTRIBUTIONS.md
@@ -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 ada65e811a..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.84+**.
-
-The easiest way to install Rust on your system is via Rustup. To get Rustup on Linux and macOS, you can run the following:
+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
@@ -19,17 +18,17 @@ curl https://sh.rustup.rs -sSf | sh
 
 Linux is fully supported by Wasmer. WASI(x) is also fully supported. Users
 building from source can enable the LLVM backend following the instruction in
-the dedicated section below and installing LLVM version 18. To install it,
+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-18.1.7) or
+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 18. To install it on
-macOS, you can use [homebrew](https://brew.sh/): `brew install llvm@18`.
+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
 
@@ -38,7 +37,7 @@ 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 18.0](https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.7/LLVM-18.1.7-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
 
@@ -92,12 +91,12 @@ variable, and force its enabling with `ENABLE_SINGLEPASS=1`.
 
 If you want support for the Wasmer LLVM compiler, then you will also need to:
 
-- Ensure that LLVM >=18.0.x is installed on your system
+- 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 18.0.x
-  would be: `LLVM_SYS_180_PREFIX=/path/to/unpacked/llvm-18.0`
+  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
 
diff --git a/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json b/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
index 6c9fe72498..22c62d3346 100644
--- a/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
+++ b/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
@@ -1,11 +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": [
-    "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.",
@@ -17,7 +14,7 @@
     "capabilities": {
       "anyOf": [
         {
-          "$ref": "#/definitions/AppConfigCapabilityMapV1"
+          "$ref": "#/$defs/AppConfigCapabilityMapV1"
         },
         {
           "type": "null"
@@ -42,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"
@@ -64,7 +61,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/HealthCheckV1"
+        "$ref": "#/$defs/HealthCheckV1"
       }
     },
     "jobs": {
@@ -73,14 +70,14 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/Job"
+        "$ref": "#/$defs/Job"
       }
     },
     "locality": {
       "description": "Location-related configuration for the app.",
       "anyOf": [
         {
-          "$ref": "#/definitions/Locality"
+          "$ref": "#/$defs/Locality"
         },
         {
           "type": "null"
@@ -103,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"
@@ -118,7 +115,7 @@
     "scaling": {
       "anyOf": [
         {
-          "$ref": "#/definitions/AppScalingConfigV1"
+          "$ref": "#/$defs/AppScalingConfigV1"
         },
         {
           "type": "null"
@@ -131,7 +128,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/definitions/AppScheduledTask"
+        "$ref": "#/$defs/AppScheduledTask"
       }
     },
     "volumes": {
@@ -140,21 +137,24 @@
         "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.",
+          "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": "#/definitions/PrettyDuration"
+              "$ref": "#/$defs/PrettyDuration"
             },
             {
               "type": "null"
@@ -163,34 +163,34 @@
         },
         "mode": {
           "description": "The method to use to generate the instaboot snapshot for the instance.",
-          "default": null,
           "anyOf": [
             {
-              "$ref": "#/definitions/InstabootSnapshotModeV1"
+              "$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"
@@ -201,7 +201,7 @@
           "description": "Instance memory settings.",
           "anyOf": [
             {
-              "$ref": "#/definitions/AppConfigCapabilityMemoryV1"
+              "$ref": "#/$defs/AppConfigCapabilityMemoryV1"
             },
             {
               "type": "null"
@@ -212,7 +212,7 @@
           "description": "Runtime settings.",
           "anyOf": [
             {
-              "$ref": "#/definitions/AppConfigCapabilityRuntimeV1"
+              "$ref": "#/$defs/AppConfigCapabilityRuntimeV1"
             },
             {
               "type": "null"
@@ -222,7 +222,7 @@
         "ssh": {
           "anyOf": [
             {
-              "$ref": "#/definitions/CapabilitySshServerV1"
+              "$ref": "#/$defs/CapabilitySshServerV1"
             },
             {
               "type": "null"
@@ -233,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": {
@@ -271,7 +271,7 @@
         "mode": {
           "anyOf": [
             {
-              "$ref": "#/definitions/AppScalingModeV1"
+              "$ref": "#/$defs/AppScalingModeV1"
             },
             {
               "type": "null"
@@ -288,21 +288,17 @@
     },
     "AppScheduledTask": {
       "type": "object",
-      "required": [
-        "name"
-      ],
       "properties": {
         "name": {
           "type": "string"
         }
-      }
+      },
+      "required": [
+        "name"
+      ]
     },
     "AppVolume": {
       "type": "object",
-      "required": [
-        "mount",
-        "name"
-      ],
       "properties": {
         "mount": {
           "type": "string"
@@ -310,7 +306,11 @@
         "name": {
           "type": "string"
         }
-      }
+      },
+      "required": [
+        "name",
+        "mount"
+      ]
     },
     "CapabilitySshServerV1": {
       "description": "Configure SSH server credentials and settings.",
@@ -329,7 +329,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/SshUserV1"
+            "$ref": "#/$defs/SshUserV1"
           }
         }
       },
@@ -341,7 +341,7 @@
         "capabilities": {
           "anyOf": [
             {
-              "$ref": "#/definitions/ExecutableJobCompatibilityMapV1"
+              "$ref": "#/$defs/ExecutableJobCompatibilityMapV1"
             },
             {
               "type": "null"
@@ -349,7 +349,7 @@
           ]
         },
         "cli_args": {
-          "description": "CLI arguments passed to the runner. Only applicable for runners that accept CLI arguments.",
+          "description": "CLI arguments passed to the runner.\nOnly applicable for runners that accept CLI arguments.",
           "type": [
             "array",
             "null"
@@ -379,7 +379,7 @@
           "description": "The package that contains the command to run. Defaults to the app config's package.",
           "anyOf": [
             {
-              "$ref": "#/definitions/PackageSource"
+              "$ref": "#/$defs/PackageSource"
             },
             {
               "type": "null"
@@ -392,7 +392,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/AppVolume"
+            "$ref": "#/$defs/AppVolume"
           }
         }
       }
@@ -404,7 +404,7 @@
           "description": "Instance memory settings.",
           "anyOf": [
             {
-              "$ref": "#/definitions/AppConfigCapabilityMemoryV1"
+              "$ref": "#/$defs/AppConfigCapabilityMemoryV1"
             },
             {
               "type": "null"
@@ -417,9 +417,6 @@
     "HealthCheckHttpV1": {
       "description": "Health check configuration for http endpoints.",
       "type": "object",
-      "required": [
-        "path"
-      ],
       "properties": {
         "body": {
           "description": "Request body as a string.",
@@ -431,7 +428,7 @@
         "expect": {
           "anyOf": [
             {
-              "$ref": "#/definitions/HttpRequestExpect"
+              "$ref": "#/$defs/HttpRequestExpect"
             },
             {
               "type": "null"
@@ -445,7 +442,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/HttpHeader"
+            "$ref": "#/$defs/HttpHeader"
           }
         },
         "healthy_threshold": {
@@ -455,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.",
@@ -479,7 +476,7 @@
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
           "anyOf": [
             {
-              "$ref": "#/definitions/PrettyDuration"
+              "$ref": "#/$defs/PrettyDuration"
             },
             {
               "type": "null"
@@ -493,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"
@@ -527,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.",
@@ -546,7 +543,7 @@
         "expect": {
           "anyOf": [
             {
-              "$ref": "#/definitions/HttpRequestExpect"
+              "$ref": "#/$defs/HttpRequestExpect"
             },
             {
               "type": "null"
@@ -560,7 +557,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/HttpHeader"
+            "$ref": "#/$defs/HttpHeader"
           }
         },
         "method": {
@@ -578,14 +575,17 @@
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
           "anyOf": [
             {
-              "$ref": "#/definitions/PrettyDuration"
+              "$ref": "#/$defs/PrettyDuration"
             },
             {
               "type": "null"
             }
           ]
         }
-      }
+      },
+      "required": [
+        "path"
+      ]
     },
     "HttpRequestExpect": {
       "description": "Validation checks for an [`HttpRequest`].",
@@ -614,7 +614,8 @@
           "items": {
             "type": "integer",
             "format": "uint16",
-            "minimum": 0.0
+            "maximum": 65535,
+            "minimum": 0
           }
         }
       }
@@ -623,65 +624,60 @@
       "description": "How will an instance be bootstrapped?",
       "oneOf": [
         {
-          "description": "Start the instance without any snapshot triggers. Once the requests are done, use [`snapshot_and_stop`](wasmer_wasix::WasiProcess::snapshot_and_stop) to capture a snapshot and shut the instance down.",
+          "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",
-          "enum": [
-            "bootstrap"
-          ]
+          "const": "bootstrap"
         },
         {
-          "description": "Explicitly enable the given snapshot triggers before starting the instance. The instance's process will have its stop_running_after_checkpoint flag set, so the first snapshot will cause the instance to shut down.",
+          "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",
-          "required": [
-            "triggers"
-          ],
           "properties": {
             "triggers": {
               "type": "array",
               "items": {
-                "$ref": "#/definitions/SnapshotTrigger"
+                "$ref": "#/$defs/SnapshotTrigger"
               }
             }
           },
-          "additionalProperties": false
+          "additionalProperties": false,
+          "required": [
+            "triggers"
+          ]
         }
       ]
     },
     "Job": {
       "description": "Job configuration.",
       "type": "object",
-      "required": [
-        "action",
-        "name",
-        "trigger"
-      ],
       "properties": {
         "action": {
-          "$ref": "#/definitions/JobAction"
+          "$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. The calculation works by multiplying the time between invocations by a random amount, and taking the percentage of that random amount.\n\nSee also [`Self::jitter_percent_min`] to set a minimum jitter.",
+          "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",
-          "minimum": 0.0
+          "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. The calculation works by multiplying the time between invocations by a random amount, and taking the percentage of that random amount.\n\nIf not specified while `jitter_percent_max` is, it will default to 10%.\n\nSee also [`Self::jitter_percent_max`] to set a maximum jitter.",
+          "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",
-          "minimum": 0.0
+          "maximum": 255,
+          "minimum": 0
         },
         "max_schedule_drift": {
-          "description": "Don't start job if past the due time by this amount, instead opting to wait for the next instance of it to be triggered.",
+          "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": "#/definitions/PrettyDuration"
+              "$ref": "#/$defs/PrettyDuration"
             },
             {
               "type": "null"
@@ -697,12 +693,12 @@
             "null"
           ],
           "format": "uint32",
-          "minimum": 0.0
+          "minimum": 0
         },
         "timeout": {
           "anyOf": [
             {
-              "$ref": "#/definitions/PrettyDuration"
+              "$ref": "#/$defs/PrettyDuration"
             },
             {
               "type": "null"
@@ -710,37 +706,40 @@
           ]
         },
         "trigger": {
-          "$ref": "#/definitions/JobTrigger"
+          "$ref": "#/$defs/JobTrigger"
         }
       },
-      "additionalProperties": true
+      "additionalProperties": true,
+      "required": [
+        "name",
+        "trigger",
+        "action"
+      ]
     },
     "JobAction": {
       "type": "object",
       "oneOf": [
         {
           "type": "object",
-          "required": [
-            "fetch"
-          ],
           "properties": {
             "fetch": {
-              "$ref": "#/definitions/HttpRequest"
+              "$ref": "#/$defs/HttpRequest"
             }
           },
-          "additionalProperties": false
+          "required": [
+            "fetch"
+          ]
         },
         {
           "type": "object",
-          "required": [
-            "execute"
-          ],
           "properties": {
             "execute": {
-              "$ref": "#/definitions/ExecutableJob"
+              "$ref": "#/$defs/ExecutableJob"
             }
           },
-          "additionalProperties": false
+          "required": [
+            "execute"
+          ]
         }
       ]
     },
@@ -749,9 +748,6 @@
     },
     "Locality": {
       "type": "object",
-      "required": [
-        "regions"
-      ],
       "properties": {
         "regions": {
           "type": "array",
@@ -759,7 +755,10 @@
             "type": "string"
           }
         }
-      }
+      },
+      "required": [
+        "regions"
+      ]
     },
     "PackageSource": {
       "type": "string"
@@ -769,40 +768,36 @@
         {
           "description": "Plain text password.",
           "type": "object",
-          "required": [
-            "password",
-            "type"
-          ],
           "properties": {
             "password": {
               "type": "string"
             },
             "type": {
               "type": "string",
-              "enum": [
-                "plain"
-              ]
+              "const": "plain"
             }
-          }
+          },
+          "required": [
+            "type",
+            "password"
+          ]
         },
         {
           "description": "Bcrypt password hash.",
           "type": "object",
-          "required": [
-            "hash",
-            "type"
-          ],
           "properties": {
             "hash": {
               "type": "string"
             },
             "type": {
               "type": "string",
-              "enum": [
-                "bcrypt"
-              ]
+              "const": "bcrypt"
             }
-          }
+          },
+          "required": [
+            "type",
+            "hash"
+          ]
         }
       ]
     },
@@ -827,9 +822,6 @@
     },
     "SshUserV1": {
       "type": "object",
-      "required": [
-        "username"
-      ],
       "properties": {
         "authorized_keys": {
           "description": "SSH public keys for this user.",
@@ -848,7 +840,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/PasswordV1"
+            "$ref": "#/$defs/PasswordV1"
           }
         },
         "username": {
@@ -856,7 +848,10 @@
           "type": "string"
         }
       },
-      "additionalProperties": true
+      "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 1d9e7bc594..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 `ExitCode`", e);
+                bail!("Unknown error `{e}` found. expected `ExitCode`");
             }
         },
     }
diff --git a/examples/engine.rs b/examples/engine.rs
index d8836de7c0..0aae886761 100644
--- a/examples/engine.rs
+++ b/examples/engine.rs
@@ -18,7 +18,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, sys::EngineBuilder, wat2wasm, 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 9bc8ca7803..c4a2856d3b 100644
--- a/examples/engine_cross_compilation.rs
+++ b/examples/engine_cross_compilation.rs
@@ -20,8 +20,9 @@
 
 use std::str::FromStr;
 use wasmer::{
+    Module, RuntimeError, Store,
     sys::{CpuFeature, EngineBuilder},
-    wat2wasm, Module, RuntimeError, Store,
+    wat2wasm,
 };
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_types::target::{Target, Triple};
@@ -65,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 984bedecf9..ec75248c51 100644
--- a/examples/engine_headless.rs
+++ b/examples/engine_headless.rs
@@ -45,7 +45,7 @@
 //! Ready?
 
 use tempfile::NamedTempFile;
-use wasmer::{imports, sys::EngineBuilder, wat2wasm, 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 c732afbfb8..5b7fce12e9 100644
--- a/examples/features.rs
+++ b/examples/features.rs
@@ -11,9 +11,9 @@
 //! Ready?
 
 use wasmer::{
-    imports,
+    Instance, Module, Store, Value, imports,
     sys::{EngineBuilder, Features},
-    wat2wasm, Instance, Module, Store, Value,
+    wat2wasm,
 };
 use wasmer_compiler_cranelift::Cranelift;
 
diff --git a/examples/funcref.rs b/examples/funcref.rs
index 548a7fde59..b555ecad91 100644
--- a/examples/funcref.rs
+++ b/examples/funcref.rs
@@ -1,5 +1,5 @@
 use std::error::Error;
-use wasmer::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+use wasmer::{Instance, Module, Store, Table, TableType, Type, Value, imports};
 
 fn main() -> Result<(), Box<dyn Error>> {
     // 1) Create a default Wasmer Store.
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 6e38860033..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>> {
@@ -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 61ac3418b4..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>> {
@@ -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 2644638708..22fb6367b2 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,11 @@ 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")?;
+    let get_at: TypedFunction<i32, i32> = instance.exports.get_typed_function(&store, "get_at")?;
     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 +89,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 +97,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
diff --git a/examples/memory_grow.rs b/examples/memory_grow.rs
index 11a587e660..1ea7992515 100644
--- a/examples/memory_grow.rs
+++ b/examples/memory_grow.rs
@@ -6,7 +6,7 @@
 //! cargo run --example memory-grow --release --features "cranelift"
 //! ```
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store};
+use wasmer::{Instance, Module, Store, imports, wat2wasm};
 
 fn main() -> anyhow::Result<()> {
     let wasm_bytes = wat2wasm(
@@ -40,7 +40,7 @@ fn main() -> anyhow::Result<()> {
     );
 
     let result = memory.grow(&mut store, 1);
-    println!("Attempt to exceed max: {:?}", result);
+    println!("Attempt to exceed max: {result:?}");
 
     Ok(())
 }
diff --git a/examples/metering.rs b/examples/metering.rs
index a9551cb96f..8e7a513688 100644
--- a/examples/metering.rs
+++ b/examples/metering.rs
@@ -18,14 +18,14 @@ use anyhow::bail;
 use std::sync::Arc;
 use wasmer::wasmparser::Operator;
 use wasmer::{
-    imports,
+    Instance, Module, Store, TypedFunction, imports,
     sys::{CompilerConfig, EngineBuilder},
-    wat2wasm, Instance, Module, Store, TypedFunction,
+    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<()> {
@@ -89,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)?;
@@ -109,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)?;
@@ -125,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
@@ -136,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.");
@@ -164,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 585ccc5bf9..69c70ec050 100644
--- a/examples/platform_ios_headless.rs
+++ b/examples/platform_ios_headless.rs
@@ -14,7 +14,7 @@
 #![allow(unused)]
 use std::path::Path;
 use std::str::FromStr;
-use wasmer::{sys::CpuFeature, wat2wasm, Module, RuntimeError, Store};
+use wasmer::{Module, RuntimeError, Store, sys::CpuFeature, wat2wasm};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_types::target::{Target, Triple};
 /*
diff --git a/examples/table.rs b/examples/table.rs
index 52e5b9f458..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 {
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 33e3b69e35..d3265f2764 100644
--- a/examples/tunables_limit_memory.rs
+++ b/examples/tunables_limit_memory.rs
@@ -3,13 +3,13 @@ use wasmer_compiler_cranelift::Cranelift;
 
 // This is to be able to set the tunables
 use wasmer::{
-    imports,
+    Engine, Instance, Memory, MemoryError, MemoryStyle, MemoryType, Module, Pages, Store,
+    TableStyle, TableType, imports,
     sys::{
-        vm::{VMMemory, VMMemoryDefinition, VMTable, VMTableDefinition},
         BaseTunables, NativeEngineExt, Target, Tunables,
+        vm::{VMMemory, VMMemoryDefinition, VMTable, VMTableDefinition},
     },
-    wat2wasm, Engine, Instance, Memory, MemoryError, MemoryStyle, MemoryType, Module, Pages, Store,
-    TableStyle, TableType,
+    wat2wasm,
 };
 
 /// A custom tunables that allows you to set a memory limit.
@@ -35,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);
         }
@@ -105,8 +105,10 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
     ) -> 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`].
@@ -125,7 +127,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
     ) -> Result<VMTable, String> {
-        self.base.create_vm_table(ty, style, vm_definition_location)
+        unsafe { self.base.create_vm_table(ty, style, vm_definition_location) }
     }
 }
 
@@ -169,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 e3bea0c5a0..1dc0fe457e 100644
--- a/examples/wasi.rs
+++ b/examples/wasi.rs
@@ -17,9 +17,9 @@
 use std::{io::Read, sync::Arc};
 
 use wasmer_wasix::{
+    Pipe, PluggableRuntime, Runtime,
     runners::wasi::{RuntimeOrEngine, WasiRunner},
     runtime::{module_cache::HashedModuleData, task_manager::tokio::TokioTaskManager},
-    Pipe, PluggableRuntime, Runtime,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs
index 93392fa8e2..d60dcb00c3 100644
--- a/examples/wasi_pipes.rs
+++ b/examples/wasi_pipes.rs
@@ -15,8 +15,8 @@ use std::io::{Read, Write};
 
 use wasmer::Module;
 use wasmer_wasix::{
-    runners::wasi::{RuntimeOrEngine, WasiRunner},
     Pipe,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -35,12 +35,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     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
diff --git a/flake.lock b/flake.lock
index 8d268d8d52..a14e238db4 100644
--- a/flake.lock
+++ b/flake.lock
@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1726560853,
-        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,16 +20,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1730137625,
-        "narHash": "sha256-9z8oOgFZiaguj+bbi3k4QhAD6JabWrnv7fscC/mt0KE=",
+        "lastModified": 1759735786,
+        "narHash": "sha256-a0+h02lyP2KwSNrZz4wLJTu9ikujNsTWIC874Bv7IJ0=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "64b80bfb316b57cdb8919a9110ef63393d74382a",
+        "rev": "20c4598c84a671783f741e02bf05cbfaf4907cff",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-24.05",
+        "ref": "nixos-25.05",
         "repo": "nixpkgs",
         "type": "github"
       }
diff --git a/flake.nix b/flake.nix
index 9e761650fb..b4cb649589 100644
--- a/flake.nix
+++ b/flake.nix
@@ -2,7 +2,7 @@
   description = "Wasmer Webassembly runtime";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
     flakeutils.url = "github:numtide/flake-utils";
   };
 
@@ -35,10 +35,15 @@
             openssl
 
             # LLVM and related dependencies
-            llvmPackages_18.libllvm
-            llvmPackages_18.llvm
+            llvmPackages_21.libllvm
+            llvmPackages_21.llvm
+            llvmPackages_21.llvm.dev
+            llvmPackages_21.libclang.dev
             libxml2
             libffi
+            cmake
+            ninja
+            webkitgtk_4_0
 
             # Rust tooling
 
@@ -67,12 +72,24 @@
             wasm-tools
           ];
 
-          env.LLVM_SYS_180_PREFIX = pkgs.llvmPackages_18.llvm.dev;
-
-          # shellHook = ''
-          #   LD_LIBRARY_PATH = "${ env.LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [ pkgs.stdenv.cc.cc pkgs.openssl.out ] }:$LD_LIBRARY_PATH"
-          # '';
-
+          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_0.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/fuzz_targets/equivalence_universal.rs b/fuzz/fuzz_targets/equivalence_universal.rs
index 4db992f314..0c1cba8469 100644
--- a/fuzz/fuzz_targets/equivalence_universal.rs
+++ b/fuzz/fuzz_targets/equivalence_universal.rs
@@ -4,7 +4,7 @@
 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 wasmer::{CompilerConfig, EngineBuilder, Instance, Module, Store, Val, imports};
 #[cfg(feature = "cranelift")]
 use wasmer_compiler_cranelift::Cranelift;
 #[cfg(feature = "llvm")]
diff --git a/fuzz/fuzz_targets/metering.rs b/fuzz/fuzz_targets/metering.rs
index 6c4f7f89f0..ac23d04932 100644
--- a/fuzz/fuzz_targets/metering.rs
+++ b/fuzz/fuzz_targets/metering.rs
@@ -4,7 +4,7 @@ use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use std::sync::Arc;
 use wasm_smith::{Config, ConfiguredModule};
 use wasmer::wasmparser::Operator;
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer::{CompilerConfig, Instance, Module, Store, imports};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_middlewares::Metering;
 
diff --git a/fuzz/fuzz_targets/universal_cranelift.rs b/fuzz/fuzz_targets/universal_cranelift.rs
index 764947f66a..ea42d7eba9 100644
--- a/fuzz/fuzz_targets/universal_cranelift.rs
+++ b/fuzz/fuzz_targets/universal_cranelift.rs
@@ -2,7 +2,7 @@
 
 use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer::{CompilerConfig, Instance, Module, Store, imports};
 use wasmer_compiler_cranelift::Cranelift;
 
 #[derive(Arbitrary, Debug, Default, Copy, Clone)]
diff --git a/fuzz/fuzz_targets/universal_llvm.rs b/fuzz/fuzz_targets/universal_llvm.rs
index 1f051f8976..2f3fc9cc27 100644
--- a/fuzz/fuzz_targets/universal_llvm.rs
+++ b/fuzz/fuzz_targets/universal_llvm.rs
@@ -2,7 +2,7 @@
 
 use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer::{CompilerConfig, Instance, Module, Store, imports};
 use wasmer_compiler_llvm::LLVM;
 
 #[derive(Arbitrary, Debug, Default, Copy, Clone)]
diff --git a/fuzz/fuzz_targets/universal_singlepass.rs b/fuzz/fuzz_targets/universal_singlepass.rs
index 762f6ece7f..2d35056383 100644
--- a/fuzz/fuzz_targets/universal_singlepass.rs
+++ b/fuzz/fuzz_targets/universal_singlepass.rs
@@ -2,7 +2,7 @@
 
 use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, Instance, Module, Store};
+use wasmer::{Instance, Module, Store, imports};
 use wasmer_compiler_singlepass::Singlepass;
 
 #[derive(Arbitrary, Debug, Default, Copy, Clone)]
diff --git a/lib/api/Cargo.toml b/lib/api/Cargo.toml
index 37f91a092f..a5c0ed4b56 100644
--- a/lib/api/Cargo.toml
+++ b/lib/api/Cargo.toml
@@ -35,13 +35,13 @@ cfg-if.workspace = true
 thiserror.workspace = true
 more-asserts.workspace = true
 bytes.workspace = true
-tracing.workspace = true
+tracing = { workspace = true, default-features = true }
 # - Optional shared dependencies.
-wat = { version = "1.216.0", optional = true }
-rustc-demangle = "0.1"
+wat = { workspace = true, optional = true }
+rustc-demangle.workspace = true
 shared-buffer.workspace = true
 
-wasmi_c_api = { version = "0.40.0", package = "wasmi_c_api_impl", optional = true, features = [
+wasmi_c_api_impl = { workspace = true, optional = true, features = [
 	"prefix-symbols",
 ] }
 
@@ -49,7 +49,7 @@ loupe = { workspace = true, optional = true, features = [
 	"indexmap",
 	"enable-indexmap",
 ] }
-paste = "1.0.15"
+paste.workspace = true
 derive_more = { workspace = true, features = ["from", "debug"] }
 
 # Dependencies and Development Dependencies for `sys`.
@@ -64,21 +64,25 @@ target-lexicon = { workspace = true, default-features = false }
 wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=6.1.0", optional = true }
 wasmer-compiler-cranelift = { path = "../compiler-cranelift", version = "=6.1.0", optional = true }
 wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=6.1.0", optional = true }
+corosensei = { workspace = true, optional = true }
+futures = { workspace = true, 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 }
+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"
+wat.workspace = true
 tempfile.workspace = true
 anyhow.workspace = true
 macro-wasmer-universal-test = { version = "6.1.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]
@@ -86,22 +90,22 @@ macro-wasmer-universal-test = { version = "6.1.0", path = "./macro-wasmer-univer
 wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = [
 	"std",
 ] }
-wasm-bindgen = "0.2.100"
-js-sys = "0.3.77"
+wasm-bindgen.workspace = true
+js-sys.workspace = true
 wasmer-derive = { path = "../derive", version = "=6.1.0" }
 wasmer-compiler = { path = "../compiler", version = "=6.1.0" }
 # - Optional dependencies for `js`.
 wasmparser = { workspace = true, default-features = false, optional = true }
 hashbrown = { workspace = true, optional = true }
-serde-wasm-bindgen = { version = "0.6.5" }
+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"
+wat.workspace = true
 anyhow.workspace = true
-wasm-bindgen-test = "0.3.0"
+wasm-bindgen-test.workspace = true
 macro-wasmer-universal-test = { version = "6.1.0", path = "./macro-wasmer-universal-test" }
 
 # Specific to `js`.
@@ -128,6 +132,9 @@ artifact-size = [
 sys = ["std", "dep:wasmer-vm", "dep:wasmer-compiler"]
 sys-default = ["sys", "wat", "cranelift"]
 
+# Experimental concurrent execution support
+experimental-async = ["sys", "dep:futures", "dep:corosensei"]
+
 # - Compilers.
 compiler = [
 	"sys",
@@ -145,7 +152,7 @@ wamr-default = ["wamr", "wat"]
 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"]
+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"]
 
@@ -183,22 +190,22 @@ static-artifact-load = ["wasmer-compiler/static-artifact-load"]
 static-artifact-create = ["wasmer-compiler/static-artifact-create"]
 
 [build-dependencies]
-cmake = "0.1.50"
+cmake.workspace = true
 tar.workspace = true
-ureq = { version = "2.10.1", optional = true }
-which = { version = "7.0.0", optional = true }
-xz = { version = "0.1.0", optional = true }
-zip = { version = "2.2.0", optional = true }
+ureq = { workspace = true, optional = true }
+which = { workspace = true, optional = true }
+xz = { workspace = true, optional = true }
+zip = { workspace = true, optional = true, default-features = true }
 
 [target.'cfg(target_env = "musl")'.build-dependencies]
-bindgen = { version = "0.70.1", default-features = false, features = [
+bindgen = { workspace = true, default-features = false, features = [
 	"static",
 	"logging",
 	"prettyplease",
 ] }
 
 [target.'cfg(not(target_env = "musl"))'.build-dependencies]
-bindgen = { version = "0.70.1" }
+bindgen = { workspace = true, default-features = true }
 
 [package.metadata.docs.rs]
 features = [
diff --git a/lib/api/build.rs b/lib/api/build.rs
index 0a440fbe27..d4968044d4 100644
--- a/lib/api/build.rs
+++ b/lib/api/build.rs
@@ -19,7 +19,7 @@ fn build_wamr() {
         "freebsd" => "freebsd",
         "android" => "android",
         "ios" => "ios",
-        other => panic!("Unsupported CARGO_CFG_TARGET_OS: {}", other),
+        other => panic!("Unsupported CARGO_CFG_TARGET_OS: {other}"),
     };
 
     // Read target arch from cargo env
@@ -32,7 +32,7 @@ fn build_wamr() {
         "mips" => "MIPS",
         "powerpc" => "POWERPC",
         "powerpc64" => "POWERPC64",
-        other => panic!("Unsupported CARGO_CFG_TARGET_ARCH: {}", other),
+        other => panic!("Unsupported CARGO_CFG_TARGET_ARCH: {other}"),
     };
 
     // Cleanup tmp data from prior builds
@@ -43,10 +43,13 @@ fn build_wamr() {
         let _ = std::fs::remove_dir_all(&zip_dir);
 
         // Fetch & extract wasm-micro-runtime source
-        let zip = ureq::get(WAMR_ZIP).call().expect("failed to download wamr");
-        let mut zip_data = Vec::new();
-        zip.into_reader()
-            .read_to_end(&mut zip_data)
+        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");
@@ -143,6 +146,11 @@ fn build_wamr() {
         ) -> Option<String> {
             if item_info.name.starts_with("wasm") {
                 let new_name = format!("wamr_{}", item_info.name);
+                // TODO: refactor to not use static mut
+                #[allow(
+                    static_mut_refs,
+                    reason = "existing behaviour that was disallowed by edition 2024"
+                )]
                 unsafe {
                     WAMR_RENAMED.push((item_info.name.to_string(), new_name.clone()));
                 }
@@ -166,8 +174,9 @@ fn build_wamr() {
         .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(out_path.join("wamr_bindings.rs"))
+        .write_to_file(&bindings_path)
         .expect("Couldn't write bindings");
 
     let objcopy_names = ["llvm-objcopy", "objcopy", "gobjcopy"];
@@ -190,6 +199,11 @@ fn build_wamr() {
     let objcopy = objcopy.unwrap();
 
     unsafe {
+        // TODO: refactor to not use static mut
+        #[allow(
+            static_mut_refs,
+            reason = "existing behaviour that was disallowed by edition 2024"
+        )]
         let syms: Vec<String> = WAMR_RENAMED
             .iter()
             .map(|(old, new)|
@@ -232,29 +246,43 @@ fn build_v8() {
     use std::{env, path::PathBuf};
 
     let url = match (
-            env::var("CARGO_CFG_TARGET_OS").unwrap().as_str(),
-            env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str(),
-            env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default().as_str(),
-        ) {
-            ("macos", "aarch64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-aarch64.tar.xz",
-            ("macos", "x86_64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-amd64.tar.xz",
-            ("linux", "x86_64", "gnu") => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-amd64.tar.xz",
-            ("linux", "x86_64", "musl") => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-musl-amd64.tar.xz",
-            ("android", "aarch64", _)  => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-android-arm64.tar.xz",
-            // Not supported in 6.0.0-alpha1
-            //("windows", "x86_64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.7-custom1/wee8-windows-amd64.tar.xz",
-            (os, arch, _) => panic!("target os + arch combination not supported: {os}, {arch}"),
-        };
+        env::var("CARGO_CFG_TARGET_OS").unwrap().as_str(),
+        env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str(),
+        env::var("CARGO_CFG_TARGET_ENV")
+            .unwrap_or_default()
+            .as_str(),
+    ) {
+        ("macos", "aarch64", _) => {
+            "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-aarch64.tar.xz"
+        }
+        ("macos", "x86_64", _) => {
+            "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-amd64.tar.xz"
+        }
+        ("linux", "x86_64", "gnu") => {
+            "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-amd64.tar.xz"
+        }
+        ("linux", "x86_64", "musl") => {
+            "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-musl-amd64.tar.xz"
+        }
+        ("android", "aarch64", _) => {
+            "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-android-arm64.tar.xz"
+        }
+        // Not supported in 6.0.0-alpha1
+        //("windows", "x86_64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.7-custom1/wee8-windows-amd64.tar.xz",
+        (os, arch, _) => panic!("target os + arch combination not supported: {os}, {arch}"),
+    };
 
     let out_dir = env::var("OUT_DIR").unwrap();
     let crate_root = env::var("CARGO_MANIFEST_DIR").unwrap();
     let v8_header_path = PathBuf::from(&crate_root).join("third-party").join("wee8");
 
-    let tar = ureq::get(url).call().expect("failed to download v8");
-
-    let mut tar_data = Vec::new();
-    tar.into_reader()
-        .read_to_end(&mut tar_data)
+    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());
@@ -268,7 +296,7 @@ fn build_v8() {
     let mut archive = tar::Archive::new(tar);
 
     archive.unpack(out_dir.clone()).unwrap();
-    println!("cargo:rustc-link-search=native={}", out_dir);
+    println!("cargo:rustc-link-search=native={out_dir}");
 
     if cfg!(any(target_os = "linux",)) {
         println!("cargo:rustc-link-lib=stdc++");
@@ -294,6 +322,11 @@ fn build_v8() {
         ) -> Option<String> {
             if item_info.name.starts_with("wasm") {
                 let new_name = format!("wee8_{}", item_info.name);
+                // TODO: refactor to not use static mut
+                #[allow(
+                    static_mut_refs,
+                    reason = "existing behaviour that was disallowed by edition 2024"
+                )]
                 unsafe {
                     WEE8_RENAMED.push((item_info.name.to_string(), new_name.clone()));
                 }
@@ -347,6 +380,11 @@ fn build_v8() {
 
     let objcopy = objcopy.unwrap();
 
+    // TODO: refactor to not use static mut
+    #[allow(
+        static_mut_refs,
+        reason = "existing behaviour that was disallowed by edition 2024"
+    )]
     unsafe {
         let syms: Vec<String> = WEE8_RENAMED
             .iter()
@@ -361,10 +399,12 @@ fn build_v8() {
                 }
             })
             .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()))
+        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();
 
@@ -421,9 +461,32 @@ fn build_wasmi() {
         .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(out_path.join("wasmi_bindings.rs"))
+        .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() {
diff --git a/lib/api/macro-wasmer-universal-test/Cargo.toml b/lib/api/macro-wasmer-universal-test/Cargo.toml
index 11d9f9acbd..5a43e597dc 100644
--- a/lib/api/macro-wasmer-universal-test/Cargo.toml
+++ b/lib/api/macro-wasmer-universal-test/Cargo.toml
@@ -1,16 +1,16 @@
 [package]
 name = "macro-wasmer-universal-test"
-version = "6.1.0"
-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-macro2 = "1.0.60"
-syn = { version = "2.0", default-features = false, features = [
+proc-macro2.workspace = true
+syn = { workspace = true, default-features = false, features = [
     "full",
     "parsing",
     "printing",
@@ -19,4 +19,4 @@ syn = { version = "2.0", default-features = false, features = [
     "extra-traits",
     "proc-macro",
 ] }
-quote = "1.0.20"
+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 2e7abc3bae..5b9274a502 100644
--- a/lib/api/macro-wasmer-universal-test/src/lib.rs
+++ b/lib/api/macro-wasmer-universal-test/src/lib.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use syn::{
-    parse::{Parse, ParseStream},
     Attribute, Signature, Visibility,
+    parse::{Parse, ParseStream},
 };
 
 #[proc_macro_attribute]
diff --git a/lib/api/src/backend/js/entities/engine.rs b/lib/api/src/backend/js/entities/engine.rs
index cdb2316c30..2be7a65522 100644
--- a/lib/api/src/backend/js/entities/engine.rs
+++ b/lib/api/src/backend/js/entities/engine.rs
@@ -1,4 +1,4 @@
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 /// The engine for the JavaScript runtime.
 #[derive(Clone, Debug)]
@@ -31,13 +31,13 @@ impl Engine {
 
 impl Default for Engine {
     fn default() -> Self {
-        Engine
+        Self
     }
 }
 
 /// Returns the default engine for the JS engine
 pub(crate) fn default_engine() -> Engine {
-    Engine::default()
+    Engine
 }
 
 impl crate::Engine {
@@ -71,11 +71,11 @@ impl crate::Engine {
     }
 }
 
-impl Into<crate::Engine> for Engine {
-    fn into(self) -> crate::Engine {
-        crate::Engine {
-            be: crate::BackendEngine::Js(self),
-            id: crate::Engine::atomic_next_engine_id(),
+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
index be352635d4..f7b8ca40c1 100644
--- a/lib/api/src/backend/js/entities/exception.rs
+++ b/lib/api/src/backend/js/entities/exception.rs
@@ -2,8 +2,8 @@
 
 use super::store::StoreHandle;
 use crate::{
-    js::vm::{VMException, VMExceptionRef},
     AsStoreMut, AsStoreRef, Tag, Value,
+    js::vm::{VMException, VMExceptionRef},
 };
 use std::any::Any;
 use wasmer_types::{TagType, Type};
@@ -20,42 +20,6 @@ unsafe impl Sync for Exception {}
 impl Exception {
     /// Create a new [`Exception`].
     pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `exnref` in `js`.
-pub(crate) struct ExceptionRef;
-
-impl ExceptionRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in js");
-    }
-
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in js");
-    }
-
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        unimplemented!("ExceptionRef is not yet supported in js");
-    }
-
-    pub(crate) unsafe fn from_vm_exceptionref(
-        _store: &mut impl AsStoreMut,
-        _vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        unimplemented!("ExceptionRef is not yet supported in js");
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+        unimplemented!("Exception handling is not yet supported in js");
     }
 }
diff --git a/lib/api/src/backend/js/entities/function/env.rs b/lib/api/src/backend/js/entities/function/env.rs
index b05024cd78..5b377a326c 100644
--- a/lib/api/src/backend/js/entities/function/env.rs
+++ b/lib/api/src/backend/js/entities/function/env.rs
@@ -1,9 +1,9 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
 use crate::{
+    StoreMut,
     js::{store::StoreHandle, vm::VMFunctionEnvironment},
     store::{AsStoreMut, AsStoreRef, StoreRef},
-    StoreMut,
 };
 
 #[derive(Debug)]
@@ -62,7 +62,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// 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,
     {
@@ -103,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,
 {
@@ -137,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
@@ -202,6 +202,6 @@ impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
 
 impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
     fn from(value: FunctionEnv<T>) -> Self {
-        crate::FunctionEnv(crate::BackendFunctionEnv::Js(value))
+        Self(crate::BackendFunctionEnv::Js(value))
     }
 }
diff --git a/lib/api/src/backend/js/entities/function/mod.rs b/lib/api/src/backend/js/entities/function/mod.rs
index 667fa091ec..d69b21d424 100644
--- a/lib/api/src/backend/js/entities/function/mod.rs
+++ b/lib/api/src/backend/js/entities/function/mod.rs
@@ -5,19 +5,19 @@ use std::marker::PhantomData;
 pub(crate) use typed::*;
 
 use js_sys::{Array, Function as JsFunction};
-use wasm_bindgen::{prelude::*, JsCast};
+use wasm_bindgen::{JsCast, prelude::*};
 use wasmer_types::{FunctionType, RawValue};
 
 use crate::{
-    js::{
-        utils::convert::{js_value_to_wasmer, wasmer_value_to_js, AsJs as _},
-        vm::{function::VMFunction, VMFuncRef, VMFunctionCallback},
-    },
-    vm::{VMExtern, VMExternFunction},
     AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnv, BackendFunctionEnvMut,
     FromToNativeWasmType, FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult,
     NativeWasmType, NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv,
     WithoutEnv,
+    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};
@@ -94,7 +94,7 @@ impl Function {
                     .map(|(i, param)| js_value_to_wasmer(param, &args.get(i as u32)))
                     .collect::<Vec<_>>();
                 let results = func(env, &wasm_arguments)?;
-                return Ok(wasmer_value_to_js(&results[0]));
+                Ok(wasmer_value_to_js(&results[0]))
             })
                 as Box<dyn FnMut(&Array) -> Result<JsValue, JsValue>>)
             .into_js_value(),
@@ -108,7 +108,7 @@ impl Function {
                     .map(|(i, param)| js_value_to_wasmer(param, &args.get(i as u32)))
                     .collect::<Vec<_>>();
                 let results = func(env, &wasm_arguments)?;
-                return Ok(wasmer_array_to_js_array(&results));
+                Ok(wasmer_array_to_js_array(&results))
             })
                 as Box<dyn FnMut(&Array) -> Result<Array, JsValue>>)
             .into_js_value(),
@@ -233,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)),
                     }
@@ -281,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.
@@ -383,15 +385,23 @@ macro_rules! impl_host_function {
                 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 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($( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                    func($(
+                        {
+                            let native = unsafe { NativeWasmTypeInto::from_abi(&mut store, $x) };
+                            FromToNativeWasmType::from_native(native)
+                        }
+                    ),* ).into_result()
                 }));
 
                 match result {
-                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                    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)),
@@ -423,22 +433,35 @@ macro_rules! impl_host_function {
                 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 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 = &*(&() as *const () as *const Func);
+                    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> =
-                          crate::backend::js::store::StoreHandle::from_internal(store2.objects_mut().id(), crate::backend::js::store::InternalStoreHandle::from_index(handle_index).unwrap());
+                          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(), $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                        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)) => return result.into_c_struct(&mut store),
+                    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)),
diff --git a/lib/api/src/backend/js/entities/function/typed.rs b/lib/api/src/backend/js/entities/function/typed.rs
index 029dd229c1..229fab787d 100644
--- a/lib/api/src/backend/js/entities/function/typed.rs
+++ b/lib/api/src/backend/js/entities/function/typed.rs
@@ -8,9 +8,9 @@
 //! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
 //! ```
 use crate::{
-    js::utils::convert::{js_value_to_wasmer, AsJs},
     AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
     TypedFunction, Value, WasmTypeList,
+    js::utils::convert::{AsJs, js_value_to_wasmer},
 };
 use js_sys::Array;
 use std::iter::FromIterator;
@@ -38,14 +38,20 @@ macro_rules! impl_native_traits {
                     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.as_js().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) {
@@ -109,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/backend/js/entities/global.rs b/lib/api/src/backend/js/entities/global.rs
index 9b5ca611e4..277e92db02 100644
--- a/lib/api/src/backend/js/entities/global.rs
+++ b/lib/api/src/backend/js/entities/global.rs
@@ -1,10 +1,10 @@
-use wasm_bindgen::{prelude::*, JsValue};
+use wasm_bindgen::{JsValue, prelude::*};
 use wasmer_types::{GlobalType, Mutability, RawValue, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
     js::vm::VMGlobal,
     vm::{VMExtern, VMExternGlobal},
-    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
 };
 use js_sys::WebAssembly;
 
@@ -127,7 +127,7 @@ 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);
diff --git a/lib/api/src/backend/js/entities/instance.rs b/lib/api/src/backend/js/entities/instance.rs
index bae0211142..7b3e2217b4 100644
--- a/lib/api/src/backend/js/entities/instance.rs
+++ b/lib/api/src/backend/js/entities/instance.rs
@@ -1,11 +1,11 @@
 use js_sys::WebAssembly;
 
 use crate::{
+    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
     js::{
         utils::{convert::AsJs, js_handle::JsHandle},
         vm::VMInstance,
     },
-    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
 };
 
 #[derive(Clone, PartialEq, Eq)]
@@ -27,9 +27,9 @@ impl Instance {
         let instance = module
             .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(
@@ -62,13 +62,13 @@ 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),
         };
 
diff --git a/lib/api/src/backend/js/entities/memory/buffer.rs b/lib/api/src/backend/js/entities/memory/buffer.rs
index c93da285fb..a582580eeb 100644
--- a/lib/api/src/backend/js/entities/memory/buffer.rs
+++ b/lib/api/src/backend/js/entities/memory/buffer.rs
@@ -1,5 +1,5 @@
 use super::Memory;
-use crate::{js::store::StoreObjects, MemoryAccessError};
+use crate::{MemoryAccessError, js::store::StoreObjects};
 use std::{marker::PhantomData, mem::MaybeUninit, slice};
 use tracing::warn;
 
@@ -10,7 +10,7 @@ pub(crate) struct MemoryBuffer<'a> {
     pub(crate) marker: PhantomData<(&'a Memory, &'a StoreObjects)>,
 }
 
-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)
@@ -26,7 +26,7 @@ impl<'a> MemoryBuffer<'a> {
             return Err(MemoryAccessError::HeapOutOfBounds);
         }
         view.subarray(offset as _, end as _)
-            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) });
+            .copy_to(unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) });
         Ok(())
     }
 
@@ -55,10 +55,10 @@ impl<'a> MemoryBuffer<'a> {
             return Err(MemoryAccessError::HeapOutOfBounds);
         }
         let buf_ptr = buf.as_mut_ptr() as *mut u8;
-        view.subarray(offset as _, end as _)
-            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf_ptr, buf.len()) });
+        let mut slice = unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) };
+        view.subarray(offset as _, end as _).copy_to(slice);
 
-        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+        Ok(slice)
     }
 
     pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
diff --git a/lib/api/src/backend/js/entities/memory/mod.rs b/lib/api/src/backend/js/entities/memory/mod.rs
index 76ff50e5d8..750bb23f72 100644
--- a/lib/api/src/backend/js/entities/memory/mod.rs
+++ b/lib/api/src/backend/js/entities/memory/mod.rs
@@ -11,9 +11,9 @@ use wasm_bindgen::JsCast;
 use wasmer_types::{MemoryError, MemoryType, Pages, WASM_PAGE_SIZE};
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendMemory,
     js::vm::memory::VMMemory,
     vm::{VMExtern, VMExternMemory},
-    AsStoreMut, AsStoreRef, BackendMemory,
 };
 
 #[derive(Debug, Clone, Eq)]
@@ -186,7 +186,7 @@ impl std::cmp::PartialEq for Memory {
 
 impl From<Memory> for crate::Memory {
     fn from(value: Memory) -> Self {
-        crate::Memory(crate::BackendMemory::Js(value))
+        Self(crate::BackendMemory::Js(value))
     }
 }
 
diff --git a/lib/api/src/backend/js/entities/memory/view.rs b/lib/api/src/backend/js/entities/memory/view.rs
index e4c451624d..628af3958e 100644
--- a/lib/api/src/backend/js/entities/memory/view.rs
+++ b/lib/api/src/backend/js/entities/memory/view.rs
@@ -91,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/module.rs b/lib/api/src/backend/js/entities/module.rs
index b734661f96..38d83bce46 100644
--- a/lib/api/src/backend/js/entities/module.rs
+++ b/lib/api/src/backend/js/entities/module.rs
@@ -3,7 +3,7 @@ use std::path::Path;
 use bytes::Bytes;
 use js_sys::{Reflect, Uint8Array, WebAssembly};
 use tracing::{debug, warn};
-use wasm_bindgen::{prelude::*, JsValue};
+use wasm_bindgen::{JsValue, prelude::*};
 use wasmer_types::{
     CompileError, DeserializeError, ExportType, ExportsIterator, ExternType, FunctionType,
     GlobalType, ImportType, ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages,
@@ -11,12 +11,12 @@ use wasmer_types::{
 };
 
 use crate::{
+    AsEngineRef, AsStoreMut, BackendModule, Extern, Imports, InstantiationError, IntoBytes,
+    RuntimeError,
     js::{
         utils::{convert::AsJs as _, js_handle::JsHandle},
         vm::VMInstance,
     },
-    AsEngineRef, AsStoreMut, BackendModule, Extern, Imports, InstantiationError, IntoBytes,
-    RuntimeError,
 };
 
 /// WebAssembly in the browser doesn't yet output the descriptor/types
@@ -71,15 +71,15 @@ impl Module {
         _engine: &impl AsEngineRef,
         binary: &[u8],
     ) -> Result<Self, CompileError> {
-        let js_bytes = Uint8Array::view(binary);
+        let js_bytes = unsafe { Uint8Array::view(binary) };
         let module = WebAssembly::Module::new(&js_bytes.into()).map_err(|e| {
-            CompileError::Validate(format!(
-                "{}",
+            CompileError::Validate(
                 e.as_string()
                     .unwrap_or("Unknown validation error".to_string())
-            ))
+                    .to_string(),
+            )
         })?;
-        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
@@ -205,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> {
@@ -257,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(
@@ -265,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 {
@@ -372,7 +372,12 @@ impl Module {
                 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);
@@ -459,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,
@@ -471,9 +476,9 @@ 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 {
+    fn from((module, binary): (WebAssembly::Module, T)) -> Self {
         unsafe {
-            crate::module::Module(BackendModule::Js(Module::from_js_module(
+            Self(BackendModule::Js(Module::from_js_module(
                 module,
                 binary.into_bytes(),
             )))
@@ -482,8 +487,8 @@ impl<T: IntoBytes> From<(WebAssembly::Module, T)> for crate::module::Module {
 }
 
 impl From<WebAssembly::Module> for crate::module::Module {
-    fn from(module: WebAssembly::Module) -> crate::module::Module {
-        crate::module::Module(BackendModule::Js(module.into()))
+    fn from(module: WebAssembly::Module) -> Self {
+        Self(BackendModule::Js(module.into()))
     }
 }
 impl From<crate::module::Module> for WebAssembly::Module {
@@ -503,16 +508,16 @@ impl crate::Module {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::js::module::Module`].
     pub fn as_js(&self) -> &crate::backend::js::module::Module {
-        match self.0 {
-            BackendModule::Js(ref s) => s,
+        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 self.0 {
-            BackendModule::Js(ref mut s) => s,
+        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
index 686da2ce41..187deda4e5 100644
--- a/lib/api/src/backend/js/entities/store/handle.rs
+++ b/lib/api/src/backend/js/entities/store/handle.rs
@@ -2,7 +2,7 @@ use std::{marker::PhantomData, num::NonZeroUsize};
 
 use wasmer_types::StoreId;
 
-use super::{obj::StoreObject, StoreObjects};
+use super::{StoreObjects, obj::StoreObject};
 
 /// Handle to an object managed by a context.
 ///
diff --git a/lib/api/src/backend/js/entities/store/obj.rs b/lib/api/src/backend/js/entities/store/obj.rs
index 4f4a75f5d0..ff840f187b 100644
--- a/lib/api/src/backend/js/entities/store/obj.rs
+++ b/lib/api/src/backend/js/entities/store/obj.rs
@@ -81,7 +81,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+    pub fn iter_globals(&self) -> core::slice::Iter<'_, VMGlobal> {
         self.globals.iter()
     }
 
diff --git a/lib/api/src/backend/js/entities/table.rs b/lib/api/src/backend/js/entities/table.rs
index 436f407991..e376facc89 100644
--- a/lib/api/src/backend/js/entities/table.rs
+++ b/lib/api/src/backend/js/entities/table.rs
@@ -1,7 +1,7 @@
 use crate::{
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
     js::vm::{VMFunction, VMTable},
     vm::{VMExtern, VMExternTable},
-    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
 };
 use js_sys::Function;
 use wasmer_types::{FunctionType, TableType};
@@ -71,7 +71,7 @@ impl Table {
     }
 
     pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
-        if let Some(func) = self.handle.table.get(index).ok() {
+        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(
@@ -151,16 +151,16 @@ impl crate::Table {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::js::table::Table`].
     pub fn as_js(&self) -> &crate::backend::js::table::Table {
-        match self.0 {
-            BackendTable::Js(ref s) => s,
+        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 self.0 {
-            BackendTable::Js(ref mut s) => s,
+        match &mut self.0 {
+            BackendTable::Js(s) => s,
             _ => panic!("Not a `js` table!"),
         }
     }
@@ -178,7 +178,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::js::table::Table`].
     pub fn as_js(&self) -> &crate::backend::js::table::Table {
         match self {
-            Self::Js(ref s) => s,
+            Self::Js(s) => s,
             _ => panic!("Not a `js` table!"),
         }
     }
@@ -186,7 +186,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::table::Table`].
     pub fn as_js_mut(&mut self) -> &mut crate::backend::js::table::Table {
         match self {
-            Self::Js(ref mut s) => s,
+            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
index b00c9c3b9f..7456d26ea0 100644
--- a/lib/api/src/backend/js/entities/tag.rs
+++ b/lib/api/src/backend/js/entities/tag.rs
@@ -1,9 +1,9 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendTag, TagKind,
     js::vm::VMTag,
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef, BackendTag, TagKind,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -24,7 +24,7 @@ impl Tag {
         let descriptor = js_sys::Object::new();
         let params: Box<[Type]> = params.into();
         let parameters: Vec<String> = params
-            .into_iter()
+            .iter()
             .map(|param| match param {
                 Type::I32 => "i32".to_string(),
                 Type::I64 => "i64".to_string(),
@@ -62,7 +62,7 @@ impl Tag {
 
 impl crate::Tag {
     /// Consume [`self`] into [`crate::backend::js::tag::Tag`].
-    pub fn into_js(self) -> 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!"),
@@ -70,7 +70,7 @@ impl crate::Tag {
     }
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::js::tag::Tag`].
-    pub fn as_js(&self) -> &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!"),
@@ -78,7 +78,7 @@ impl crate::Tag {
     }
 
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::tag::Tag`].
-    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::tag::Tag {
+    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/backend/js/error.rs b/lib/api/src/backend/js/error.rs
index f52554a18b..7b5e28fb75 100644
--- a/lib/api/src/backend/js/error.rs
+++ b/lib/api/src/backend/js/error.rs
@@ -1,9 +1,12 @@
 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 {
@@ -50,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]
@@ -81,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()),
         })
     }
@@ -111,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.
@@ -150,27 +160,27 @@ 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 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"),
         }
     }
 }
@@ -195,13 +205,13 @@ impl From<Trap> for RuntimeError {
             return trap.downcast::<Self>().unwrap();
         }
 
-        RuntimeError::new_from_source(crate::BackendTrap::Js(trap), vec![], None)
+        Self::new_from_source(crate::BackendTrap::Js(trap), vec![], None)
     }
 }
 
 impl From<RuntimeError> for wasm_bindgen::JsValue {
     fn from(value: RuntimeError) -> Self {
-        wasm_bindgen::JsValue::from(value.to_string())
+        Self::from(value.to_string())
     }
 }
 
diff --git a/lib/api/src/backend/js/utils/convert.rs b/lib/api/src/backend/js/utils/convert.rs
index c65008478f..a8c00724f7 100644
--- a/lib/api/src/backend/js/utils/convert.rs
+++ b/lib/api/src/backend/js/utils/convert.rs
@@ -8,6 +8,7 @@ use wasm_bindgen::{JsCast, JsError, JsValue};
 use wasmer_types::ExternType;
 
 use crate::{
+    Extern, Function, Global, Memory, Table, Tag, Type,
     imports::Imports,
     instance::Instance,
     js::{
@@ -16,7 +17,6 @@ use crate::{
     },
     store::{AsStoreMut, AsStoreRef},
     value::Value,
-    Extern, Function, Global, Memory, Table, Tag, Type,
 };
 
 /// Convert the given type to a [`JsValue`].
@@ -236,8 +236,8 @@ 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 {
+            .map_err(|e| JsError::new(&format!("Can't get the instance: {e:?}")))?;
+        Ok(Self {
             _inner: crate::BackendInstance::Js(instance),
             module: module.clone(),
             exports,
@@ -258,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,
-                crate::vm::VMExternMemory::Js(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:?}",
             )))
         }
     }
@@ -284,7 +283,7 @@ 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,
                 crate::vm::VMExternFunction::Js(VMFunction::new(
                     value.clone().unchecked_into::<JsFunction>(),
@@ -293,8 +292,7 @@ impl AsJs for Function {
             ))
         } else {
             Err(JsError::new(&format!(
-                "Extern expect to be of type Function, but received {:?}",
-                value
+                "Extern expect to be of type Function, but received {value:?}",
             )))
         }
     }
@@ -312,7 +310,7 @@ impl AsJs for Tag {
         value: &JsValue,
     ) -> Result<Self, JsError> {
         if value.is_instance_of::<JsTag>() {
-            Ok(Tag::from_vm_extern(
+            Ok(Self::from_vm_extern(
                 store,
                 crate::vm::VMExternTag::Js(VMTag::new(
                     value.clone().unchecked_into::<JsTag>(),
@@ -321,8 +319,7 @@ impl AsJs for Tag {
             ))
         } else {
             Err(JsError::new(&format!(
-                "Extern expect to be of type Tag, but received {:?}",
-                value
+                "Extern expect to be of type Tag, but received {value:?}",
             )))
         }
     }
@@ -341,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,
                 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:?}",
             )))
         }
     }
@@ -370,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,
                 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/backend/js/utils/js_handle.rs b/lib/api/src/backend/js/utils/js_handle.rs
index 043cc1eb28..c9ff1be1c9 100644
--- a/lib/api/src/backend/js/utils/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/vm/memory.rs b/lib/api/src/backend/js/vm/memory.rs
index 706694b746..4a15d8ea91 100644
--- a/lib/api/src/backend/js/vm/memory.rs
+++ b/lib/api/src/backend/js/vm/memory.rs
@@ -42,12 +42,12 @@ impl VMMemory {
     }
 
     /// Attempts to clone this memory (if its clonable)
-    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+    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<VMMemory, wasmer_types::MemoryError> {
+    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);
@@ -80,21 +80,21 @@ impl VMMemory {
         }
 
         src.copy_to_memory(amount as u64, &dst).map_err(|err| {
-            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", 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(),
+            ty: self.ty,
         })
     }
 }
 
 impl From<VMMemory> for JsValue {
     fn from(value: VMMemory) -> Self {
-        JsValue::from(value.memory)
+        Self::from(value.memory)
     }
 }
 
diff --git a/lib/api/src/backend/jsc/entities/engine.rs b/lib/api/src/backend/jsc/entities/engine.rs
index c026f4b18f..11e735f3a1 100644
--- a/lib/api/src/backend/jsc/entities/engine.rs
+++ b/lib/api/src/backend/jsc/entities/engine.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use rusty_jsc::{JSContext, JSObject};
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 use crate::{AsEngineRef, AsStoreRef};
 
@@ -105,21 +105,21 @@ impl IntoJSC for crate::engine::EngineRef<'_> {
 impl IntoJSC for crate::store::StoreRef<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().jsc()
+        self.engine().jsc()
     }
 }
 
 impl IntoJSC for crate::store::StoreMut<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().jsc()
+        self.engine().jsc()
     }
 }
 
 impl IntoJSC for crate::Store {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().jsc()
+        self.engine().jsc()
     }
 }
 
@@ -266,11 +266,11 @@ impl crate::Engine {
     }
 }
 
-impl Into<crate::Engine> for Engine {
-    fn into(self) -> crate::Engine {
-        crate::Engine {
-            be: crate::BackendEngine::Jsc(self),
-            id: crate::Engine::atomic_next_engine_id(),
+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
index f7a2a63f99..beb8949c98 100644
--- a/lib/api/src/backend/jsc/entities/exception.rs
+++ b/lib/api/src/backend/jsc/entities/exception.rs
@@ -4,8 +4,8 @@ use std::any::Any;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    jsc::vm::{VMException, VMExceptionRef},
     AsStoreMut, AsStoreRef, Tag, Value,
+    jsc::vm::{VMException, VMExceptionRef},
 };
 
 use super::store::StoreHandle;
@@ -22,42 +22,6 @@ unsafe impl Sync for Exception {}
 impl Exception {
     /// Create a new [`Exception`].
     pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `exnref` in `jsc`.
-pub(crate) struct ExceptionRef;
-
-impl ExceptionRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in jsc");
-    }
-
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in jsc");
-    }
-
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        unimplemented!("ExceptionRef is not yet supported in jsc");
-    }
-
-    pub(crate) unsafe fn from_vm_exceptionref(
-        _store: &mut impl AsStoreMut,
-        _vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        unimplemented!("ExceptionRef is not yet supported in jsc");
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+        unimplemented!("Exception handling is not yet supported in jsc");
     }
 }
diff --git a/lib/api/src/backend/jsc/entities/function/env.rs b/lib/api/src/backend/jsc/entities/function/env.rs
index 81f4aef391..88739f08a5 100644
--- a/lib/api/src/backend/jsc/entities/function/env.rs
+++ b/lib/api/src/backend/jsc/entities/function/env.rs
@@ -1,9 +1,9 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
 use crate::{
+    StoreMut,
     jsc::{store::StoreHandle, vm::VMFunctionEnvironment},
     store::{AsStoreMut, AsStoreRef, StoreRef},
-    StoreMut,
 };
 
 #[derive(Debug)]
@@ -62,7 +62,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// Convert it into a `FunctionEnvMut`
-    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    pub fn into_mut<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, T>
     where
         T: Any + Send + 'static + Sized,
     {
@@ -137,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<'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
@@ -196,12 +196,12 @@ impl<T> crate::FunctionEnv<T> {
 
 impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
     fn from(value: FunctionEnvMut<'a, T>) -> Self {
-        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Jsc(value))
+        Self(crate::BackendFunctionEnvMut::Jsc(value))
     }
 }
 
 impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
     fn from(value: FunctionEnv<T>) -> Self {
-        crate::FunctionEnv(crate::BackendFunctionEnv::Jsc(value))
+        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
index 6856dfeeb2..afe36b214a 100644
--- a/lib/api/src/backend/jsc/entities/function/mod.rs
+++ b/lib/api/src/backend/jsc/entities/function/mod.rs
@@ -2,22 +2,22 @@ pub(crate) mod env;
 pub(crate) mod typed;
 
 use rusty_jsc::{
-    callback, callback_closure, JSContext, JSObject, JSObjectCallAsFunctionCallback, JSValue,
+    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::{jsc_value_to_wasmer, AsJsc},
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
         vm::{VMFuncRef, VMFunction, VMFunctionEnvironment},
     },
     vm::VMExtern,
-    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, FromToNativeWasmType,
-    FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult, NativeWasmType,
-    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
 };
 
 use super::engine::IntoJSC;
@@ -91,17 +91,17 @@ impl Function {
                 .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);
+                let value = format!("{e}");
                 JSValue::string(&ctx, value)
             })?;
             match new_function_type.results().len() {
                 0 => Ok(JSValue::undefined(&ctx)),
-                1 => Ok(results[0].as_jsc_value(&mut store)),
+                1 => Ok(results[0].as_jsc_value(&store)),
                 _ => Ok(JSObject::new_array(
                     &ctx,
                     &results
                         .into_iter()
-                        .map(|result| result.as_jsc_value(&mut store))
+                        .map(|result| result.as_jsc_value(&store))
                         .collect::<Vec<_>>(),
                 )?
                 .to_jsvalue()),
@@ -148,23 +148,23 @@ impl Function {
         let callback = function.callback(store.jsc().context());
 
         let bind = callback
-            .get_property(&context, "bind".to_string())
-            .to_object(&context)
+            .get_property(context, "bind".to_string())
+            .to_object(context)
             .unwrap();
         let callback_with_env = bind
             .call(
-                &context,
+                context,
                 Some(&callback),
                 &[
-                    JSValue::undefined(&context),
+                    JSValue::undefined(context),
                     JSValue::number(
-                        &context,
+                        context,
                         env.as_jsc().handle.internal_handle().index() as f64,
                     ),
                 ],
             )
             .unwrap()
-            .to_object(&context)
+            .to_object(context)
             .unwrap();
 
         let ty = function.ty();
@@ -201,9 +201,9 @@ impl Function {
         let mut global = context.get_global_object();
         let store_ptr = store_mut.as_raw() as usize;
         global.set_property(
-            &context,
+            context,
             "__store_ptr".to_string(),
-            JSValue::number(&context, store_ptr as _),
+            JSValue::number(context, store_ptr as _),
         );
 
         let params_list = params
@@ -217,7 +217,7 @@ impl Function {
                 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);
+                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) => {
@@ -227,7 +227,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)),
                     }
@@ -243,15 +243,15 @@ impl Function {
         match result_types.len() {
             0 => Ok(Box::new([])),
             1 => {
-                let value = jsc_value_to_wasmer(&context, &result_types[0], &result);
+                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();
+                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)
+                        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())
@@ -294,7 +294,7 @@ impl std::fmt::Debug for Function {
 /// 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)]
+#[derive(Clone, Debug, Hash)]
 pub struct WasmFunction<Args = (), Rets = ()> {
     callback: JSObjectCallAsFunctionCallback,
     _phantom: PhantomData<(Args, Rets)>,
@@ -397,28 +397,31 @@ macro_rules! impl_host_function {
             {
                 use std::convert::TryInto;
 
-                let func: &Func = &*(&() as *const () as *const Func);
+                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 = StoreMut::from_raw(store_ptr as usize as *mut _);
+                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( $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()
+                    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 {
@@ -427,27 +430,22 @@ macro_rules! impl_host_function {
                             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 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 = result.into_array(&mut store);
+                                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];
-                                    Value::from_raw(&mut store, *ret_type, raw).as_jsc_value(&mut store)
+                                    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())
                             }
                         }
                     },
-                    #[cfg(feature = "std")]
-                    Ok(Err(err)) => {
-                        let trap = crate::backend::jsc::error::Trap::user(Box::new(err));
-                        Err(trap.into_jsc_value(&ctx))
-                    },
-                    #[cfg(feature = "core")]
                     Ok(Err(err)) => {
                         let trap = crate::backend::jsc::error::Trap::user(Box::new(err));
                         Err(trap.into_jsc_value(&ctx))
@@ -488,33 +486,44 @@ macro_rules! impl_host_function {
             {
                 use std::convert::TryInto;
 
-                let func: &Func = &*(&() as *const () as *const Func);
+                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 = StoreMut::from_raw(store_ptr as usize as *mut _);
+                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> = StoreHandle::from_internal(store.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
+                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 = StoreMut::from_raw(store_ptr as usize as *mut _);
-                    func(BackendFunctionEnvMut::Jsc(env).into(), $( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
-                        // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
-                        // so the only thing we can do is parse from the string repr
-                        if $x.is_number(&ctx) {
-                            $x.to_number(&ctx).unwrap() as _
-                        }
-                        else {
-                            $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
-                        }
-                    } }) ) ),* ).into_result()
+                    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 {
@@ -525,9 +534,9 @@ macro_rules! impl_host_function {
                                 // unimplemented!();
 
                                 let ty = Rets::wasm_types()[0];
-                                let mut arr = result.into_array(&mut store);
+                                let mut arr = unsafe { 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 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);
@@ -536,23 +545,18 @@ macro_rules! impl_host_function {
                                 // if !results.is_array(&context) {
                                 //     panic!("Expected results to be an array.")
                                 // }
-                                let mut arr = result.into_array(&mut store);
+                                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];
-                                    Value::from_raw(&mut store, *ret_type, raw).as_jsc_value(&mut store)
+                                    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())
                             }
                         }
                     },
-                    #[cfg(feature = "std")]
                     Ok(Err(err)) => {
-                        let trap = crate::jsc::vm::Trap::user(Box::new(err));
-                        Err(trap.into_jsc_value(&ctx))
-                    },
-                    #[cfg(feature = "core")]
-                    Ok(Err(err)) => {
-                        let trap = crate::jsc::vm::Trap::user(Box::new(err));
+                        let trap = crate::backend::jsc::error::Trap::user(Box::new(err));
                         Err(trap.into_jsc_value(&ctx))
                     },
                     Err(panic) => {
diff --git a/lib/api/src/backend/jsc/entities/function/typed.rs b/lib/api/src/backend/jsc/entities/function/typed.rs
index 846da4e462..b0d3c3026f 100644
--- a/lib/api/src/backend/jsc/entities/function/typed.rs
+++ b/lib/api/src/backend/jsc/entities/function/typed.rs
@@ -9,13 +9,13 @@
 //! ```
 // use std::panic::{catch_unwind, AssertUnwindSafe};
 use crate::{
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
     backend::jsc::{
         engine::IntoJSC,
         error::Trap,
-        utils::convert::{jsc_value_to_wasmer, AsJsc},
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
     },
-    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
-    TypedFunction, Value, WasmTypeList,
 };
 
 use rusty_jsc::JSValue;
@@ -49,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;
@@ -60,7 +60,7 @@ macro_rules! impl_native_traits {
                         let context = store_mut.jsc().context();
                         r = self.func.as_jsc().handle.function
                             .call(
-                                &context,
+                                context,
                                 None,
                                 &params_list,
                             );
@@ -92,20 +92,20 @@ macro_rules! impl_native_traits {
                     0 => {},
                     1 => unsafe {
                         let ty = Rets::wasm_types()[0];
-                        let val = jsc_value_to_wasmer(&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 = jsc_value_to_wasmer(&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);
                             }
@@ -141,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
index e0a35269bc..3b55df5694 100644
--- a/lib/api/src/backend/jsc/entities/global.rs
+++ b/lib/api/src/backend/jsc/entities/global.rs
@@ -2,12 +2,12 @@ use rusty_jsc::{JSObject, JSValue};
 use wasmer_types::{GlobalType, Mutability, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
     jsc::{
-        utils::convert::{jsc_value_to_wasmer, AsJsc},
+        utils::convert::{AsJsc, jsc_value_to_wasmer},
         vm::VMGlobal,
     },
     vm::VMExtern,
-    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
 };
 
 use super::store::StoreObject;
@@ -45,7 +45,7 @@ impl Global {
         let engine = store_mut.engine();
         let context = engine.as_jsc().context();
 
-        let mut descriptor = JSObject::new(&context);
+        let mut descriptor = JSObject::new(context);
         let type_str = match val.ty() {
             Type::I32 => "i32",
             Type::I64 => "i64",
@@ -59,22 +59,22 @@ impl Global {
         // This is the value type as string, even though is incorrectly called "value"
         // in the JS API.
         descriptor.set_property(
-            &context,
+            context,
             "value".to_string(),
-            JSValue::string(&context, type_str.to_string()),
+            JSValue::string(context, type_str.to_string()),
         );
         descriptor.set_property(
-            &context,
+            context,
             "mutable".to_string(),
-            JSValue::boolean(&context, mutability.is_mutable()),
+            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(|e| <JSValue as Into<RuntimeError>>::into(e))?;
+            .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());
@@ -92,8 +92,8 @@ impl Global {
         let value = self
             .handle
             .global
-            .get_property(&context, "value".to_string());
-        jsc_value_to_wasmer(&context, &self.handle.ty.ty, &value)
+            .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> {
@@ -103,8 +103,8 @@ impl Global {
         let context = engine.as_jsc().context();
         self.handle
             .global
-            .set_property(&context, "value".to_string(), new_value)
-            .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))
+            .set_property(context, "value".to_string(), new_value)
+            .map_err(<JSValue as Into<RuntimeError>>::into)
     }
 
     pub(crate) fn from_vm_extern(
diff --git a/lib/api/src/backend/jsc/entities/instance.rs b/lib/api/src/backend/jsc/entities/instance.rs
index f7074dcf74..7e46e9a798 100644
--- a/lib/api/src/backend/jsc/entities/instance.rs
+++ b/lib/api/src/backend/jsc/entities/instance.rs
@@ -1,6 +1,6 @@
 use crate::{
-    jsc::{utils::convert::AsJsc, vm::VMInstance},
     AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
 };
 
 use super::engine::IntoJSC;
@@ -15,6 +15,7 @@ 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,
@@ -23,11 +24,12 @@ impl Instance {
         let instance = module
             .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,
@@ -40,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,
@@ -49,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<_>>();
@@ -63,7 +66,7 @@ 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 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_))
             })
diff --git a/lib/api/src/backend/jsc/entities/memory/buffer.rs b/lib/api/src/backend/jsc/entities/memory/buffer.rs
index ef0846974c..ef47d23ab6 100644
--- a/lib/api/src/backend/jsc/entities/memory/buffer.rs
+++ b/lib/api/src/backend/jsc/entities/memory/buffer.rs
@@ -89,51 +89,59 @@ 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        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);
+    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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        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);
+    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
index 1ef1b4249b..04b974b667 100644
--- a/lib/api/src/backend/jsc/entities/memory/mod.rs
+++ b/lib/api/src/backend/jsc/entities/memory/mod.rs
@@ -4,7 +4,7 @@ pub(crate) use view::*;
 pub(crate) mod buffer;
 pub(crate) use buffer::*;
 
-use crate::{jsc::vm::VMMemory, vm::VMExtern, AsStoreMut, AsStoreRef, BackendMemory};
+use crate::{AsStoreMut, AsStoreRef, BackendMemory, jsc::vm::VMMemory, vm::VMExtern};
 use rusty_jsc::{JSObject, JSValue};
 use wasmer_types::{MemoryError, MemoryType, Pages};
 
@@ -42,30 +42,30 @@ impl Memory {
         let engine = store_ref.engine();
         let context = engine.as_jsc().context();
 
-        let mut descriptor = JSObject::new(&context);
+        let mut descriptor = JSObject::new(context);
         descriptor.set_property(
-            &context,
+            context,
             "initial".to_string(),
-            JSValue::number(&context, ty.minimum.0.into()),
+            JSValue::number(context, ty.minimum.0.into()),
         );
         if let Some(max) = ty.maximum {
             descriptor.set_property(
-                &context,
+                context,
                 "maximum".to_string(),
-                JSValue::number(&context, max.0.into()),
+                JSValue::number(context, max.0.into()),
             );
         }
         descriptor.set_property(
-            &context,
+            context,
             "shared".to_string(),
-            JSValue::boolean(&context, ty.shared),
+            JSValue::boolean(context, ty.shared),
         );
 
         engine
             .as_jsc()
             .wasm_memory_type()
-            .construct(&context, &[descriptor.to_jsvalue()])
-            .map_err(|e| MemoryError::Generic(format!("{:?}", e)))
+            .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 {
@@ -121,15 +121,15 @@ impl Memory {
         let func = self
             .handle
             .memory
-            .get_property(&context, "grow".to_string())
-            .to_object(&context)
+            .get_property(context, "grow".to_string())
+            .to_object(context)
             .unwrap();
         match func.call(
-            &context,
+            context,
             Some(&self.handle.memory),
-            &[JSValue::number(&context, pages.0 as _)],
+            &[JSValue::number(context, pages.0 as _)],
         ) {
-            Ok(val) => Ok(Pages(val.to_number(&context).unwrap() as _)),
+            Ok(val) => Ok(Pages(val.to_number(context).unwrap() as _)),
             Err(e) => {
                 let old_pages = pages;
                 Err(MemoryError::CouldNotGrow {
diff --git a/lib/api/src/backend/jsc/entities/memory/view.rs b/lib/api/src/backend/jsc/entities/memory/view.rs
index cfdae79c29..686ebc7005 100644
--- a/lib/api/src/backend/jsc/entities/memory/view.rs
+++ b/lib/api/src/backend/jsc/entities/memory/view.rs
@@ -28,12 +28,12 @@ impl<'a> MemoryView<'a> {
         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();
@@ -71,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.
@@ -86,7 +86,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+        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/module.rs b/lib/api/src/backend/jsc/entities/module.rs
index 8cdc47be67..4d7e2f1136 100644
--- a/lib/api/src/backend/jsc/entities/module.rs
+++ b/lib/api/src/backend/jsc/entities/module.rs
@@ -9,9 +9,9 @@ use wasmer_types::{
 };
 
 use crate::{
-    jsc::{utils::convert::AsJsc, vm::VMInstance},
     AsEngineRef, AsStoreMut, AsStoreRef, BackendModule, Imports, InstantiationError, IntoBytes,
     RuntimeError,
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
 };
 
 use super::engine::IntoJSC;
@@ -51,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
@@ -84,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()
             ))),
         }
     }
@@ -114,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_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_jsc_value(&store.as_store_ref()),
                     );
                     imports_object
                         .set_property(
-                            &context,
+                            context,
                             import_type.module().to_string(),
                             import_namespace.to_jsvalue(),
                         )
@@ -163,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> {
@@ -175,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(
@@ -200,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(
@@ -208,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 {
diff --git a/lib/api/src/backend/jsc/entities/store/obj.rs b/lib/api/src/backend/jsc/entities/store/obj.rs
index e15b1cde40..e840a257a2 100644
--- a/lib/api/src/backend/jsc/entities/store/obj.rs
+++ b/lib/api/src/backend/jsc/entities/store/obj.rs
@@ -80,7 +80,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+    pub fn iter_globals<'a>(&'a self) -> core::slice::Iter<'a, VMGlobal> {
         self.globals.iter()
     }
 
diff --git a/lib/api/src/backend/jsc/entities/table.rs b/lib/api/src/backend/jsc/entities/table.rs
index a5a2873e69..7f3d71f2bb 100644
--- a/lib/api/src/backend/jsc/entities/table.rs
+++ b/lib/api/src/backend/jsc/entities/table.rs
@@ -2,9 +2,9 @@ use rusty_jsc::{JSObject, JSValue};
 use wasmer_types::TableType;
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
     jsc::vm::{VMExternTable, VMTable},
     vm::VMExtern,
-    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -35,30 +35,30 @@ impl Table {
         let engine = store_mut.engine();
         let context = engine.as_jsc().context();
 
-        let mut descriptor = JSObject::new(&context);
+        let mut descriptor = JSObject::new(context);
         descriptor.set_property(
-            &context,
+            context,
             "initial".to_string(),
-            JSValue::number(&context, ty.minimum.into()),
+            JSValue::number(context, ty.minimum.into()),
         );
         if let Some(max) = ty.maximum {
             descriptor.set_property(
-                &context,
+                context,
                 "maximum".to_string(),
-                JSValue::number(&context, max.into()),
+                JSValue::number(context, max.into()),
             );
         }
         descriptor.set_property(
-            &context,
+            context,
             "element".to_string(),
-            JSValue::string(&context, "anyfunc".to_string()),
+            JSValue::string(context, "anyfunc".to_string()),
         );
 
         let js_table = engine
             .as_jsc()
             .wasm_table_type()
-            .construct(&context, &[descriptor.to_jsvalue()])
-            .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))?;
+            .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 })
     }
@@ -94,8 +94,8 @@ impl Table {
         let context = engine.as_jsc().context();
         self.handle
             .table
-            .get_property(&context, "length".to_string())
-            .to_number(&context)
+            .get_property(context, "length".to_string())
+            .to_number(context)
             .unwrap() as _
     }
 
@@ -111,15 +111,15 @@ impl Table {
         let func = self
             .handle
             .table
-            .get_property(&context, "grow".to_string())
-            .to_object(&context)
+            .get_property(context, "grow".to_string())
+            .to_object(context)
             .unwrap();
         match func.call(
-            &context,
+            context,
             Some(&self.handle.table),
-            &[JSValue::number(&context, delta as _)],
+            &[JSValue::number(context, delta as _)],
         ) {
-            Ok(val) => Ok(val.to_number(&context).unwrap() as _),
+            Ok(val) => Ok(val.to_number(context).unwrap() as _),
             Err(e) => Err(<JSValue as Into<RuntimeError>>::into(e)),
         }
     }
@@ -187,7 +187,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::table::Table`].
     pub fn as_jsc(&self) -> &crate::backend::jsc::table::Table {
         match self {
-            Self::Jsc(ref s) => s,
+            Self::Jsc(s) => s,
             _ => panic!("Not a `jsc` table!"),
         }
     }
@@ -195,7 +195,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::table::Table`].
     pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::table::Table {
         match self {
-            Self::Jsc(ref mut s) => s,
+            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
index c77261b6c3..55def4d396 100644
--- a/lib/api/src/backend/jsc/entities/tag.rs
+++ b/lib/api/src/backend/jsc/entities/tag.rs
@@ -1,9 +1,9 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef,
     jsc::vm::VMTag,
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/jsc/error.rs b/lib/api/src/backend/jsc/error.rs
index 65b79012ab..02feb2cf89 100644
--- a/lib/api/src/backend/jsc/error.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 {
         }
     }
 
+    /// 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_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");
@@ -122,6 +132,6 @@ impl From<Trap> for RuntimeError {
             return trap.downcast::<Self>().unwrap();
         }
 
-        RuntimeError::new_from_source(crate::BackendTrap::Jsc(trap), vec![], None)
+        Self::new_from_source(crate::BackendTrap::Jsc(trap), vec![], None)
     }
 }
diff --git a/lib/api/src/backend/jsc/utils/convert.rs b/lib/api/src/backend/jsc/utils/convert.rs
index 3128134eab..1b545b2f04 100644
--- a/lib/api/src/backend/jsc/utils/convert.rs
+++ b/lib/api/src/backend/jsc/utils/convert.rs
@@ -1,7 +1,7 @@
 use rusty_jsc::{JSContext, JSValue};
 use wasmer_types::{ExternType, Type};
 
-use crate::{jsc::engine::IntoJSC, AsStoreMut, AsStoreRef, Extern, Function, Value};
+use crate::{AsStoreMut, AsStoreRef, Extern, Function, Value, jsc::engine::IntoJSC};
 
 /// Convert the given type to a [`JsValue`].
 pub trait AsJsc: Sized {
@@ -20,13 +20,13 @@ pub trait AsJsc: Sized {
 #[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::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 _
+            let number = if js_val.is_number(context) {
+                js_val.to_number(context).unwrap() as _
             } else {
                 js_val
-                    .to_string(&context)
+                    .to_string(context)
                     .unwrap()
                     .to_string()
                     .parse()
@@ -34,14 +34,14 @@ pub fn jsc_value_to_wasmer(context: &JSContext, ty: &Type, js_val: &JSValue) ->
             };
             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::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 _
+            let number = if js_val.is_number(context) {
+                js_val.to_number(context).unwrap() as _
             } else {
                 js_val
-                    .to_string(&context)
+                    .to_string(context)
                     .unwrap()
                     .to_string()
                     .parse()
@@ -63,17 +63,17 @@ impl AsJsc for Value {
         let engine = store.as_store_ref();
         let context = engine.jsc().context();
         match self {
-            Self::I32(i) => JSValue::number(&context, *i as _),
+            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::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::FuncRef(None) => JSValue::null(context),
             Self::ExternRef(_) => {
                 unimplemented!("ExternRefs are not yet supported in the JSC Function API",)
             }
@@ -119,7 +119,7 @@ impl AsJsc for Extern {
         let context = engine.jsc().context();
         match extern_type {
             ExternType::Function(function_type) => {
-                let obj_val = val.to_object(&context).unwrap();
+                let obj_val = val.to_object(context).unwrap();
                 Ok(Self::Function(Function::from_vm_extern(
                     store,
                     crate::vm::VMExternFunction::Jsc(
@@ -131,32 +131,32 @@ impl AsJsc for Extern {
                 )))
             }
             ExternType::Global(global_type) => {
-                let obj_val = val.to_object(&context).unwrap();
+                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.clone(),
+                        *global_type,
                     )),
                 )))
             }
             ExternType::Memory(memory_type) => {
-                let obj_val = val.to_object(&context).unwrap();
+                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.clone(),
+                        *memory_type,
                     )),
                 )))
             }
             ExternType::Table(table_type) => {
-                let obj_val = val.to_object(&context).unwrap();
+                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.clone(),
+                        *table_type,
                     )),
                 )))
             }
diff --git a/lib/api/src/backend/jsc/vm/memory.rs b/lib/api/src/backend/jsc/vm/memory.rs
index a75bfae4f2..60460a568a 100644
--- a/lib/api/src/backend/jsc/vm/memory.rs
+++ b/lib/api/src/backend/jsc/vm/memory.rs
@@ -34,12 +34,12 @@ impl VMMemory {
     }
 
     /// Attempts to clone this memory (if its clonable)
-    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+    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<VMMemory, wasmer_types::MemoryError> {
+    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");
@@ -50,14 +50,14 @@ impl VMMemory {
         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))
+            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(),
+            ty: self.ty,
         })
     }
 }
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
index dee040f955..53648e7049 100644
--- a/lib/api/src/backend/sys/entities/engine.rs
+++ b/lib/api/src/backend/sys/entities/engine.rs
@@ -4,7 +4,7 @@ use std::{path::Path, sync::Arc};
 
 use shared_buffer::OwnedBuffer;
 pub use wasmer_compiler::{Artifact, BaseTunables, Engine, EngineBuilder, Tunables};
-use wasmer_types::{target::Target, DeserializeError, Features, HashAlgorithm};
+use wasmer_types::{DeserializeError, Features, HashAlgorithm, target::Target};
 
 use crate::{BackendEngine, BackendModule};
 
@@ -153,11 +153,9 @@ impl NativeEngineExt for crate::engine::Engine {
         file_ref: &Path,
     ) -> Result<crate::Module, DeserializeError> {
         let file = std::fs::File::open(file_ref)?;
-        let artifact = Arc::new(Artifact::deserialize_unchecked(
-            self.as_sys(),
-            OwnedBuffer::from_file(&file)
-                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
-        )?);
+        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),
         )))
@@ -168,11 +166,9 @@ impl NativeEngineExt for crate::engine::Engine {
         file_ref: &Path,
     ) -> Result<crate::Module, DeserializeError> {
         let file = std::fs::File::open(file_ref)?;
-        let artifact = Arc::new(Artifact::deserialize(
-            self.as_sys(),
-            OwnedBuffer::from_file(&file)
-                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
-        )?);
+        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),
         )))
diff --git a/lib/api/src/backend/sys/entities/exception.rs b/lib/api/src/backend/sys/entities/exception.rs
index 751184cd8d..32c3d2e2c4 100644
--- a/lib/api/src/backend/sys/entities/exception.rs
+++ b/lib/api/src/backend/sys/entities/exception.rs
@@ -2,85 +2,97 @@
 use std::any::Any;
 
 use wasmer_types::{TagType, Type};
-use wasmer_vm::StoreHandle;
+use wasmer_vm::{StoreHandle, StoreId};
 
 use crate::{
-    sys::vm::{VMException, VMExceptionRef},
-    AsStoreMut, AsStoreRef, Tag, Value,
+    AsStoreMut, AsStoreRef, BackendTag, Tag, Value,
+    sys::vm::{VMExceptionObj, VMExceptionRef},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-/// A WebAssembly `exception` in the `sys` runtime.
+/// A WebAssembly `exnref` in the `sys` runtime.
 pub(crate) struct Exception {
-    pub(crate) handle: VMException,
+    exnref: wasmer_vm::VMExceptionRef,
 }
 
-unsafe impl Send for Exception {}
-unsafe impl Sync for Exception {}
-
 impl Exception {
-    /// Create a new [`Exception`].
-    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
+    /// 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");
+        }
 
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `extern ref` in the `sys` runtime.
-pub(crate) struct ExceptionRef {
-    handle: StoreHandle<wasmer_vm::VMExceptionObj>,
-}
+        let store_objects = store.as_store_ref().objects().as_sys();
+        let store_id = store_objects.id();
 
-impl ExceptionRef {
-    /// Make a new extern reference
-    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        Self {
-            handle: crate::backend::sys::store::StoreHandle::new(
-                store.objects_mut().as_sys_mut(),
-                wasmer_vm::VMExceptionObj::new(value),
-            ),
+        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 }
     }
 
-    /// 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>()
+    pub fn exnref(&self) -> wasmer_vm::VMExceptionRef {
+        self.exnref.clone()
     }
 
-    /// Create a [`VMExceptionRef`] from [`Self`].
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        wasmer_vm::VMExceptionRef(self.handle.internal_handle())
+    pub fn from_exnref(exnref: wasmer_vm::VMExceptionRef) -> Self {
+        Self { exnref }
     }
 
-    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
-    pub(crate) unsafe fn from_vm_exceptionref(
-        store: &mut impl AsStoreMut,
-        vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        Self {
-            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_exceptionref.0),
+    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) },
         }
     }
 
-    /// Checks whether this `ExceptionRef` can be used with the given context.
-    ///
-    /// Primitive (`i32`, `i64`, etc) and null funcref/exceptionref values are not
-    /// tied to a context and can be freely shared between contexts.
-    ///
-    /// exceptionref and funcref values are tied to a context and can only be used
-    /// with that context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.handle.store_id() == store.as_store_ref().objects().id()
+    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()
     }
 }
 
diff --git a/lib/api/src/backend/sys/entities/external.rs b/lib/api/src/backend/sys/entities/external.rs
index b014029b2e..ac1cc3ad1a 100644
--- a/lib/api/src/backend/sys/entities/external.rs
+++ b/lib/api/src/backend/sys/entities/external.rs
@@ -48,7 +48,7 @@ impl ExternRef {
         vm_externref: VMExternRef,
     ) -> Self {
         Self {
-            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_externref.0),
+            handle: unsafe { StoreHandle::from_internal(store.objects_mut().id(), vm_externref.0) },
         }
     }
 
diff --git a/lib/api/src/backend/sys/entities/function/env.rs b/lib/api/src/backend/sys/entities/function/env.rs
index 362804a593..db823169b8 100644
--- a/lib/api/src/backend/sys/entities/function/env.rs
+++ b/lib/api/src/backend/sys/entities/function/env.rs
@@ -1,11 +1,13 @@
 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},
-    StoreMut,
 };
 
-use wasmer_vm::{StoreHandle, StoreObject, StoreObjects, VMFunctionEnvironment};
+use wasmer_vm::{StoreHandle, StoreId, StoreObject, StoreObjects, VMFunctionEnvironment};
 
 #[derive(Debug)]
 #[repr(transparent)]
@@ -16,12 +18,9 @@ pub struct FunctionEnv<T> {
     marker: PhantomData<T>,
 }
 
-impl<T> FunctionEnv<T> {
+impl<T: Any + Send + 'static + Sized> FunctionEnv<T> {
     /// Make a new FunctionEnv
-    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
-    where
-        T: Any + Send + 'static + Sized,
-    {
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self {
         Self {
             handle: StoreHandle::new(
                 store.as_store_mut().objects_mut().as_sys_mut(),
@@ -31,18 +30,6 @@ impl<T> FunctionEnv<T> {
         }
     }
 
-    /// Get the data as reference
-    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
-    where
-        T: Any + Send + 'static + Sized,
-    {
-        self.handle
-            .get(store.as_store_ref().objects().as_sys())
-            .as_ref()
-            .downcast_ref::<T>()
-            .unwrap()
-    }
-
     #[allow(dead_code)] // This function is only used in js
     pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
         Self {
@@ -51,28 +38,33 @@ impl<T> FunctionEnv<T> {
         }
     }
 
+    /// 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
-    where
-        T: Any + Send + 'static + Sized,
-    {
+    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()
     }
-
-    /// Convert it into a `FunctionEnvMut`
-    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
-    where
-        T: Any + Send + 'static + Sized,
-    {
-        FunctionEnvMut {
-            store_mut: store.as_store_mut(),
-            func_env: self,
-        }
-    }
 }
 
 impl<T> crate::FunctionEnv<T> {
@@ -165,7 +157,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
@@ -174,6 +166,16 @@ impl<T: Send + 'static> FunctionEnvMut<'_, T> {
         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> {
@@ -207,3 +209,205 @@ impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
         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
index e032cb5c6f..04a364f9bf 100644
--- a/lib/api/src/backend/sys/entities/function/mod.rs
+++ b/lib/api/src/backend/sys/entities/function/mod.rs
@@ -3,21 +3,34 @@
 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},
-    BackendFunction, FunctionEnv, FunctionEnvMut, FunctionType, HostFunction, RuntimeError,
-    StoreInner, Value, WithEnv, WithoutEnv,
 };
 use std::panic::{self, AssertUnwindSafe};
-use std::{cell::UnsafeCell, cmp::max, ffi::c_void};
-use wasmer_types::{NativeWasmType, RawValue};
+use 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::{
-    on_host_stack, raise_user_trap, resume_panic, wasmer_call_trampoline, MaybeInstanceOwned,
-    StoreHandle, VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMFuncRef,
-    VMFunction, VMFunctionBody, VMFunctionContext, VMFunctionKind, VMTrampoline,
+    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))]
@@ -50,46 +63,39 @@ impl Function {
         let function_type = ty.into();
         let func_ty = function_type.clone();
         let func_env = env.clone().into_sys();
-        let raw_store = store.as_store_mut().as_raw() as *mut u8;
-        let wrapper = move |values_vec: *mut RawValue| -> Result<(), RuntimeError> {
+        let store_id = store.objects_mut().id();
+        let wrapper = move |values_vec: *mut RawValue| -> HostCallOutcome {
             unsafe {
-                let mut store = StoreMut::from_raw(raw_store as *mut StoreInner);
+                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 store_mut,
                         *ty,
                         values_vec.add(i).read_unaligned(),
                     ));
                 }
-                let store_mut = StoreMut::from_raw(raw_store as *mut StoreInner);
                 let env = env::FunctionEnvMut {
                     store_mut,
                     func_env: func_env.clone(),
                 }
                 .into();
-                let returns = func(env, &args)?;
-
-                // We need to dynamically check that the returns
-                // 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).write_unaligned(ret.as_raw(&store));
+                let sig = func_ty.clone();
+                let result = func(env, &args);
+                HostCallOutcome::Ready {
+                    func_ty: sig,
+                    result,
                 }
             }
-            Ok(())
         };
         let mut host_data = Box::new(VMDynamicFunctionContext {
             address: std::ptr::null(),
-            ctx: DynamicFunction { func: wrapper },
+            ctx: DynamicFunction {
+                func: wrapper,
+                store_id,
+            },
         });
         host_data.address = host_data.ctx.func_body_ptr();
 
@@ -98,7 +104,7 @@ impl Function {
         // generated dynamic trampoline.
         let func_ptr = std::ptr::null() as VMFunctionCallback;
         let type_index = store
-            .as_store_mut()
+            .as_store_ref()
             .engine()
             .as_sys()
             .register_signature(&function_type);
@@ -120,7 +126,122 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
+            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),
         }
     }
 
@@ -134,14 +255,14 @@ impl Function {
         let env = FunctionEnv::new(store, ());
         let func_ptr = func.function_callback_sys().into_sys();
         let host_data = Box::new(StaticFunction {
-            raw_store: store.as_store_mut().as_raw() as *mut u8,
+            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_mut()
+            .as_store_ref()
             .engine()
             .as_sys()
             .register_signature(&function_type);
@@ -164,10 +285,117 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
+            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>,
@@ -180,14 +408,14 @@ impl Function {
     {
         let func_ptr = func.function_callback_sys().into_sys();
         let host_data = Box::new(StaticFunction {
-            raw_store: store.as_store_mut().as_raw() as *mut u8,
+            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_mut()
+            .as_store_ref()
             .engine()
             .as_sys()
             .register_signature(&function_type);
@@ -210,7 +438,7 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
         }
     }
 
@@ -284,15 +512,25 @@ impl Function {
     ) -> 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(
-                        store.as_store_ref().signal_handler(),
+                        signal_handler,
                         config,
                         vm_function.anyfunc.as_ptr().as_ref().vmctx,
                         trampoline,
@@ -317,8 +555,12 @@ impl Function {
                 }
                 break;
             }
+
+            drop(store_install_guard);
+
             r
         };
+
         if let Err(error) = result {
             return Err(error.into());
         }
@@ -345,7 +587,7 @@ impl Function {
     ) -> Result<Box<[Value]>, RuntimeError> {
         let trampoline = unsafe {
             self.handle
-                .get(store.as_store_ref().objects().as_sys())
+                .get(store.objects_mut().as_sys())
                 .anyfunc
                 .as_ptr()
                 .as_ref()
@@ -356,6 +598,18 @@ impl Function {
         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(
@@ -365,7 +619,7 @@ impl Function {
     ) -> Result<Box<[Value]>, RuntimeError> {
         let trampoline = unsafe {
             self.handle
-                .get(store.as_store_ref().objects().as_sys())
+                .get(store.objects_mut().as_sys())
                 .anyfunc
                 .as_ptr()
                 .as_ref()
@@ -385,12 +639,15 @@ impl Function {
     }
 
     pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
-        let signature = store
-            .as_store_ref()
-            .engine()
-            .as_sys()
-            .lookup_signature(funcref.0.as_ref().type_index)
-            .expect("Signature not found in store");
+        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,
@@ -407,10 +664,7 @@ impl 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.into_sys(),
-                )
+                StoreHandle::from_internal(store.objects_mut().id(), vm_extern.into_sys())
             },
         }
     }
@@ -425,24 +679,170 @@ impl Function {
     }
 }
 
+// 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) -> Result<(), RuntimeError> + 'static,
+    F: Fn(*mut RawValue) -> HostCallOutcome + 'static,
 {
     // This function wraps our func, to make it compatible with the
     // reverse trampoline signature
-    unsafe extern "C" fn func_wrapper(
+    unsafe extern "C-unwind" 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).map_err(Box::new)
+            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,
+                    ))
+                }
             }))
         });
 
@@ -450,9 +850,23 @@ where
         // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
         // See: https://github.com/wasmerio/wasmer/pull/5700
         match result {
-            Ok(Ok(())) => {}
-            Ok(Err(trap)) => raise_user_trap(trap),
-            Err(panic) => resume_panic(panic),
+            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) },
         }
     }
 
@@ -471,8 +885,10 @@ where
     ) {
         // 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);
+        unsafe {
+            let dynamic_function = &mut *(vmctx as *mut VMDynamicFunctionContext<Self>);
+            Self::func_wrapper(dynamic_function, args);
+        }
     }
 }
 
@@ -480,7 +896,7 @@ where
 /// [`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) store_id: StoreId,
     pub(crate) env: FunctionEnv<T>,
     pub(crate) func: F,
 }
@@ -521,20 +937,23 @@ macro_rules! impl_host_function {
             /// 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
+            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 mut store = StoreMut::from_raw(env.raw_store as *mut _);
                 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 = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                            let $x = unsafe {
+                                FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x))
+                            };
                         )*
-                        (env.func)($($x),* ).into_result().map_err(Box::new)
+                        to_invocation_result((env.func)($($x),* ).into_result())
                     }))
                 });
 
@@ -542,9 +961,30 @@ macro_rules! impl_host_function {
                 // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
                 // See: https://github.com/wasmerio/wasmer/pull/5700
                 match result {
-                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                    Ok(Err(trap)) => raise_user_trap(trap),
-                    Err(panic) => resume_panic(panic) ,
+                    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) },
                 }
             }
 
@@ -563,15 +1003,17 @@ macro_rules! impl_host_function {
                 body: crate::backend::sys::vm::VMFunctionCallback,
                 args: *mut RawValue,
             ) {
-                let body: unsafe extern "C" fn(vmctx: *mut crate::backend::sys::vm::VMContext, $( $x: <$x::Native as NativeWasmType>::Abi, )*) -> Rets::CStruct = std::mem::transmute(body);
                 let mut _n = 0;
-                $(
-                    let $x = *args.add(_n).cast();
-                    _n += 1;
-                )*
 
-                let results = body(vmctx, $( $x ),*);
-                Rets::write_c_struct_to_ptr(results, args);
+                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 _
@@ -585,26 +1027,27 @@ macro_rules! impl_host_function {
             /// 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
+            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 mut store = StoreMut::from_raw(env.raw_store as *mut _);
                 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 = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                            let $x = unsafe {
+                                FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x))
+                            };
                         )*
-                        let store_mut = StoreMut::from_raw(env.raw_store as *mut _);
                         let f_env = crate::backend::sys::function::env::FunctionEnvMut {
-                            store_mut,
+                            store_mut: store,
                             func_env: env.env.as_sys().clone(),
                         }.into();
-                        (env.func)(f_env, $($x),* ).into_result().map_err(Box::new)
+                        to_invocation_result((env.func)(f_env, $($x),* ).into_result())
                     }))
                 });
 
@@ -612,9 +1055,30 @@ macro_rules! impl_host_function {
                 // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
                 // See: https://github.com/wasmerio/wasmer/pull/5700
                 match result {
-                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                    Ok(Err(trap)) => raise_user_trap(trap),
-                    Err(panic) => resume_panic(panic),
+                    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 _
@@ -630,15 +1094,18 @@ macro_rules! impl_host_function {
                   body: crate::backend::sys::vm::VMFunctionCallback,
                   args: *mut RawValue,
             ) {
-                let body: unsafe extern "C" fn(vmctx: *mut crate::backend::sys::vm::VMContext, $( $x: <$x::Native as NativeWasmType>::Abi, )*) -> Rets::CStruct = std::mem::transmute(body);
-                let mut _n = 0;
-                $(
-                let $x = *args.add(_n).cast();
-                _n += 1;
-                )*
+                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);
+                    let results = body(vmctx, $( $x ),*);
+
+                    Rets::write_c_struct_to_ptr(results, args);
+                }
             }
 
             call_trampoline::<$( $x, )* Rets> as _
diff --git a/lib/api/src/backend/sys/entities/function/typed.rs b/lib/api/src/backend/sys/entities/function/typed.rs
index 53f5f9c1a1..8616234ca9 100644
--- a/lib/api/src/backend/sys/entities/function/typed.rs
+++ b/lib/api/src/backend/sys/entities/function/typed.rs
@@ -1,7 +1,13 @@
 use crate::backend::sys::engine::NativeEngineExt;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::{FromToNativeWasmType, NativeWasmTypeInto, RuntimeError, TypedFunction, WasmTypeList};
-use wasmer_types::RawValue;
+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 ),* ) => {
@@ -46,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,
@@ -71,6 +86,9 @@ macro_rules! impl_native_traits {
                     }
                     break;
                 }
+
+                drop(store_install_guard);
+
                 r?;
 
                 let num_rets = rets_list.len();
@@ -99,6 +117,38 @@ 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)]
@@ -128,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,
@@ -154,6 +213,9 @@ macro_rules! impl_native_traits {
                     }
                     break;
                 }
+
+                drop(store_install_guard);
+
                 r?;
 
                 let num_rets = rets_list.len();
@@ -200,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
 );
@@ -212,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/backend/sys/entities/global.rs b/lib/api/src/backend/sys/entities/global.rs
index 893db3f47a..8d3b8754e9 100644
--- a/lib/api/src/backend/sys/entities/global.rs
+++ b/lib/api/src/backend/sys/entities/global.rs
@@ -59,7 +59,7 @@ impl Global {
         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"));
         }
diff --git a/lib/api/src/backend/sys/entities/instance.rs b/lib/api/src/backend/sys/entities/instance.rs
index 0219939529..15edc83407 100644
--- a/lib/api/src/backend/sys/entities/instance.rs
+++ b/lib/api/src/backend/sys/entities/instance.rs
@@ -1,8 +1,8 @@
 //! Data types, functions and traits for `sys` runtime's `Instance` implementation.
 
 use crate::{
-    error::InstantiationError, exports::Exports, imports::Imports, module::Module,
-    store::AsStoreMut, Extern,
+    Extern, error::InstantiationError, exports::Exports, imports::Imports, module::Module,
+    store::AsStoreMut,
 };
 use wasmer_vm::{StoreHandle, VMInstance};
 
@@ -14,22 +14,6 @@ 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 {
@@ -105,3 +89,19 @@ impl crate::BackendInstance {
         }
     }
 }
+
+#[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/backend/sys/entities/memory/mod.rs b/lib/api/src/backend/sys/entities/memory/mod.rs
index faa2a51d38..ed16d22095 100644
--- a/lib/api/src/backend/sys/entities/memory/mod.rs
+++ b/lib/api/src/backend/sys/entities/memory/mod.rs
@@ -11,11 +11,11 @@ use wasmer_types::{MemoryType, Pages};
 use wasmer_vm::{LinearMemory, MemoryError, StoreHandle, ThreadConditionsHandle, VMMemory};
 
 use crate::{
+    BackendMemory, MemoryAccessError,
     backend::sys::entities::{engine::NativeEngineExt, memory::MemoryView},
     entities::store::{AsStoreMut, AsStoreRef},
     location::{MemoryLocation, SharedMemoryOps},
     vm::{VMExtern, VMExternMemory},
-    BackendMemory, MemoryAccessError,
 };
 
 pub(crate) mod view;
@@ -147,12 +147,7 @@ impl SharedMemoryOps for ThreadConditionsHandle {
         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)
     }
 
@@ -161,20 +156,25 @@ impl SharedMemoryOps for ThreadConditionsHandle {
         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> {
@@ -284,52 +284,63 @@ impl MemoryBuffer<'_> {
 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>();
-    }
 
-    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();
+            (*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>();
+        }
     }
-    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);
+        }
     }
 }
 
diff --git a/lib/api/src/backend/sys/entities/memory/view.rs b/lib/api/src/backend/sys/entities/memory/view.rs
index 9fb4e04c77..e68c9b81e5 100644
--- a/lib/api/src/backend/sys/entities/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;
@@ -67,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.
@@ -82,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/module.rs b/lib/api/src/backend/sys/entities/module.rs
index b2a4d63d97..cd12fd60c1 100644
--- a/lib/api/src/backend/sys/entities/module.rs
+++ b/lib/api/src/backend/sys/entities/module.rs
@@ -10,8 +10,9 @@ use wasmer_types::{
 };
 
 use crate::{
+    AsStoreMut, AsStoreRef, BackendModule, IntoBytes, StoreContext,
     backend::sys::entities::engine::NativeEngineExt, engine::AsEngineRef,
-    error::InstantiationError, vm::VMInstance, AsStoreMut, AsStoreRef, BackendModule, IntoBytes,
+    error::InstantiationError, vm::VMInstance,
 };
 
 #[derive(Clone, PartialEq, Eq)]
@@ -88,11 +89,14 @@ impl Module {
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
         let bytes = bytes.into_bytes();
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .as_sys()
-            .deserialize_unchecked(bytes.into())?;
+
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .as_sys()
+                .deserialize_unchecked(bytes.into())?
+        };
         Ok(Self::from_artifact(artifact))
     }
 
@@ -102,11 +106,13 @@ impl Module {
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
         let bytes = bytes.into_bytes();
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .as_sys()
-            .deserialize(bytes.into())?;
+        let artifact = unsafe {
+            engine
+                .as_engine_ref()
+                .engine()
+                .as_sys()
+                .deserialize(bytes.into())?
+        };
         Ok(Self::from_artifact(artifact))
     }
 
@@ -114,11 +120,13 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .as_sys()
-            .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))
     }
 
@@ -126,11 +134,13 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        let artifact = engine
-            .as_engine_ref()
-            .engine()
-            .as_sys()
-            .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))
     }
 
@@ -157,6 +167,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 {
@@ -169,6 +180,9 @@ impl Module {
                 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
@@ -177,6 +191,8 @@ impl Module {
             self.artifact
                 .finish_instantiation(config, signal_handler, &mut instance_handle)?;
 
+            drop(store_install_guard);
+
             Ok(VMInstance::Sys(instance_handle))
         }
     }
diff --git a/lib/api/src/backend/sys/entities/store/mod.rs b/lib/api/src/backend/sys/entities/store/mod.rs
index 43a171eb3d..2763b2c08c 100644
--- a/lib/api/src/backend/sys/entities/store/mod.rs
+++ b/lib/api/src/backend/sys/entities/store/mod.rs
@@ -1,8 +1,8 @@
 //! Data types, functions and traits for `sys` runtime's `Store` implementation.
-use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
 use crate::BackendStore;
-use wasmer_vm::init_traps;
+use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
 use wasmer_vm::TrapHandlerFn;
+use wasmer_vm::init_traps;
 pub use wasmer_vm::{StoreHandle, StoreObjects};
 
 mod obj;
@@ -70,18 +70,6 @@ impl NativeStoreExt for Store {
     }
 }
 
-impl NativeStoreExt for crate::Store {
-    fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
-        self.inner.store.as_sys_mut().set_trap_handler(handler)
-    }
-
-    /// The signal handler
-    #[inline]
-    fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
-        self.inner.store.as_sys().signal_handler()
-    }
-}
-
 impl crate::BackendStore {
     /// Consume [`self`] into [`crate::backend::sys::store::Store`].
     pub fn into_sys(self) -> crate::backend::sys::store::Store {
@@ -111,25 +99,3 @@ impl crate::BackendStore {
         matches!(self, Self::Sys(_))
     }
 }
-
-impl crate::Store {
-    /// Consume [`self`] into [`crate::backend::sys::store::Store`].
-    pub(crate) fn into_sys(self) -> crate::backend::sys::store::Store {
-        self.inner.store.into_sys()
-    }
-
-    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::store::Store`].
-    pub(crate) fn as_sys(&self) -> &crate::backend::sys::store::Store {
-        self.inner.store.as_sys()
-    }
-
-    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::store::Store`].
-    pub(crate) fn as_sys_mut(&mut self) -> &mut crate::backend::sys::store::Store {
-        self.inner.store.as_sys_mut()
-    }
-
-    /// Return true if [`self`] is a store from the `sys` runtime.
-    pub fn is_sys(&self) -> bool {
-        self.inner.store.is_sys()
-    }
-}
diff --git a/lib/api/src/backend/sys/entities/store/obj.rs b/lib/api/src/backend/sys/entities/store/obj.rs
index ba90370dc1..0bb27b8967 100644
--- a/lib/api/src/backend/sys/entities/store/obj.rs
+++ b/lib/api/src/backend/sys/entities/store/obj.rs
@@ -27,50 +27,3 @@ impl crate::StoreObjects {
         }
     }
 }
-
-//pub trait GetStoreObjects {
-//    /// Return a mutable reference to [`wasmer_vm::StoreObjects`] and a reference to the current
-//    /// engine.
-//    fn engine_and_objects_mut(
-//        &mut self,
-//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects);
-//
-//    /// Return a mutable reference to [`wasmer_vm::StoreObjects`].
-//    fn objects_mut(&mut self) -> &mut crate::backend::sys::store::StoreObjects;
-//}
-//
-//impl GetStoreObjects for crate::StoreInner {
-//    fn objects_mut(&mut self) -> &mut crate::backend::sys::store::StoreObjects {
-//        self.objects.as_sys_mut()
-//    }
-//
-//    fn engine_and_objects_mut(
-//        &mut self,
-//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects) {
-//        match (&mut self.objects, &self.store) {
-//            (crate::StoreObjects::Sys(o), crate::BackendStore::Sys(s)) => (&s.engine, o),
-//            _ => panic!("Not a `sys` store!"),
-//        }
-//    }
-//}
-//
-//impl<T: AsStoreMut> GetStoreObjects for T {
-//    fn objects_mut<'a>(&'a mut self) -> &'a mut crate::backend::sys::store::StoreObjects {
-//        match self.as_store_mut().inner.objects {
-//            crate::StoreObjects::Sys(ref mut s) => s,
-//            _ => panic!("Not a `sys` store!"),
-//        }
-//    }
-//
-//    fn engine_and_objects_mut(
-//        &mut self,
-//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects) {
-//        let mut store = self.as_store_mut();
-//        match (&mut store.inner.objects, &store.inner.store) {
-//            (crate::StoreObjects::Sys(ref mut o), crate::BackendStore::Sys(ref s)) => {
-//                (&s.engine, o)
-//            }
-//            _ => panic!("Not a `sys` store!"),
-//        }
-//    }
-//}
diff --git a/lib/api/src/backend/sys/entities/table.rs b/lib/api/src/backend/sys/entities/table.rs
index 6888da892d..88cd08ae0d 100644
--- a/lib/api/src/backend/sys/entities/table.rs
+++ b/lib/api/src/backend/sys/entities/table.rs
@@ -1,10 +1,10 @@
 //! 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},
-    BackendTable, ExternRef, Function, Value,
 };
 use wasmer_types::TableType;
 use wasmer_vm::{StoreHandle, TableElement, Trap, VMTable};
@@ -199,16 +199,16 @@ impl crate::Table {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::sys::table::Table`].
     pub fn as_sys(&self) -> &crate::backend::sys::table::Table {
-        match self.0 {
-            BackendTable::Sys(ref s) => s,
+        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 self.0 {
-            BackendTable::Sys(ref mut s) => s,
+        match &mut self.0 {
+            BackendTable::Sys(s) => s,
             _ => panic!("Not a `sys` table!"),
         }
     }
@@ -226,7 +226,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::sys::table::Table`].
     pub fn as_sys(&self) -> &crate::backend::sys::table::Table {
         match self {
-            Self::Sys(ref s) => s,
+            Self::Sys(s) => s,
             _ => panic!("Not a `sys` table!"),
         }
     }
@@ -234,7 +234,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::table::Table`].
     pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::table::Table {
         match self {
-            Self::Sys(ref mut s) => s,
+            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
index 8f1de9b06a..5845251343 100644
--- a/lib/api/src/backend/sys/entities/tag.rs
+++ b/lib/api/src/backend/sys/entities/tag.rs
@@ -3,9 +3,9 @@ use wasmer_types::{FunctionType, TagType, Type};
 use wasmer_vm::StoreHandle;
 
 use crate::{
+    AsStoreMut, AsStoreRef,
     sys::vm::VMTag,
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/sys/error.rs b/lib/api/src/backend/sys/error.rs
index e8ced176cd..950c7b021d 100644
--- a/lib/api/src/backend/sys/error.rs
+++ b/lib/api/src/backend/sys/error.rs
@@ -1,5 +1,5 @@
 use crate::LinkError;
-use wasmer_vm::Trap;
+use wasmer_vm::{Trap, VMExceptionRef};
 
 impl From<wasmer_compiler::LinkError> for LinkError {
     fn from(other: wasmer_compiler::LinkError) -> Self {
diff --git a/lib/api/src/backend/sys/mod.rs b/lib/api/src/backend/sys/mod.rs
index ab009c0dc2..4e8ea874b7 100644
--- a/lib/api/src/backend/sys/mod.rs
+++ b/lib/api/src/backend/sys/mod.rs
@@ -1,5 +1,7 @@
 //! 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;
@@ -11,17 +13,17 @@ pub use tunables::*;
 
 #[cfg(feature = "compiler")]
 pub use wasmer_compiler::{
-    wasmparser, CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware,
+    CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware, wasmparser,
 };
 
 pub use wasmer_compiler::{Artifact, EngineBuilder, Features, Tunables};
 
-pub use wasmer_types::target::{Architecture, CpuFeature, OperatingSystem, Target, Triple};
 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::{LLVMOptLevel, LLVM};
+pub use wasmer_compiler_llvm::{LLVM, LLVMOptLevel};
 #[cfg(feature = "singlepass")]
 pub use wasmer_compiler_singlepass::Singlepass;
diff --git a/lib/api/src/backend/sys/tunables.rs b/lib/api/src/backend/sys/tunables.rs
index 018ee72b0a..232de0c60a 100644
--- a/lib/api/src/backend/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;
@@ -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,7 +221,7 @@ 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
@@ -258,7 +258,7 @@ mod tests {
     fn check_custom_tunables() -> Result<(), Box<dyn std::error::Error>> {
         #[cfg(feature = "wat")]
         use crate::wat2wasm;
-        use crate::{imports, Engine, Instance, Memory, Module, Store};
+        use crate::{Engine, Instance, Memory, Module, Store, imports};
 
         let wasm_bytes = wat2wasm(
             br#"(module
@@ -315,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
diff --git a/lib/api/src/backend/sys/vm.rs b/lib/api/src/backend/sys/vm.rs
index ee1816d0f8..6e13d34a26 100644
--- a/lib/api/src/backend/sys/vm.rs
+++ b/lib/api/src/backend/sys/vm.rs
@@ -3,9 +3,6 @@ use crate::entities::{Function, Global, Memory, Table, Tag};
 use crate::store::AsStoreMut;
 pub use wasmer_vm::*;
 
-// No EH for now.
-pub(crate) type VMException = ();
-
 /// The type of extern tables in the `sys` VM.
 pub type VMExternTable = InternalStoreHandle<VMTable>;
 ///
diff --git a/lib/api/src/backend/v8/entities/engine.rs b/lib/api/src/backend/v8/entities/engine.rs
index 5e5e44de7c..73acd9b2a3 100644
--- a/lib/api/src/backend/v8/entities/engine.rs
+++ b/lib/api/src/backend/v8/entities/engine.rs
@@ -1,10 +1,10 @@
 //! Data types, functions and traits for `sys` runtime's `Engine` implementation.
 use crate::{
-    backend::v8::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
     BackendEngine,
+    backend::v8::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
 };
 use std::sync::Arc;
-use wasmer_types::{target::Target, Features};
+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);
@@ -114,9 +114,9 @@ impl crate::Engine {
 
 impl From<Engine> for crate::Engine {
     fn from(value: Engine) -> Self {
-        crate::Engine {
+        Self {
             be: BackendEngine::V8(value),
-            id: crate::Engine::atomic_next_engine_id(),
+            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
index 7923ab57c9..2a11939501 100644
--- a/lib/api/src/backend/v8/entities/exception.rs
+++ b/lib/api/src/backend/v8/entities/exception.rs
@@ -4,8 +4,8 @@ use std::any::Any;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    v8::vm::{VMException, VMExceptionRef},
     AsStoreMut, AsStoreRef, Tag, Value,
+    v8::vm::{VMException, VMExceptionRef},
 };
 
 use super::store::StoreHandle;
@@ -22,42 +22,6 @@ unsafe impl Sync for Exception {}
 impl Exception {
     /// Create a new [`Exception`].
     pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `extern ref` in `v8`.
-pub(crate) struct ExceptionRef;
-
-impl ExceptionRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in v8");
-    }
-
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in v8");
-    }
-
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        unimplemented!("ExceptionRef is not yet supported in v8");
-    }
-
-    pub(crate) unsafe fn from_vm_exceptionref(
-        _store: &mut impl AsStoreMut,
-        _vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        unimplemented!("ExceptionRef is not yet supported in v8");
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+        unimplemented!("Exception handling is not yet supported in v8");
     }
 }
diff --git a/lib/api/src/backend/v8/entities/function/env.rs b/lib/api/src/backend/v8/entities/function/env.rs
index efaf1ab7a2..cff3675a38 100644
--- a/lib/api/src/backend/v8/entities/function/env.rs
+++ b/lib/api/src/backend/v8/entities/function/env.rs
@@ -1,9 +1,9 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
 use crate::{
+    StoreMut,
     store::{AsStoreMut, AsStoreRef, StoreRef},
     v8::{store::StoreHandle, vm::VMFunctionEnvironment},
-    StoreMut,
 };
 
 #[derive(Debug)]
@@ -62,7 +62,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// Convert it into a `FunctionEnvMut`
-    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    pub fn into_mut<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, T>
     where
         T: Any + Send + 'static + Sized,
     {
@@ -137,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<'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
@@ -208,6 +208,6 @@ impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
 
 impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
     fn from(value: FunctionEnv<T>) -> Self {
-        crate::FunctionEnv(crate::BackendFunctionEnv::V8(value))
+        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
index 67278428d3..fd5fe497e6 100644
--- a/lib/api/src/backend/v8/entities/function/mod.rs
+++ b/lib/api/src/backend/v8/entities/function/mod.rs
@@ -6,15 +6,15 @@ use std::{
 };
 
 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},
-    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
-    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
-    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
 };
 
 use super::{super::error::Trap, check_isolate, store::StoreHandle};
@@ -91,9 +91,9 @@ impl Function {
         let params = fn_ty.params();
 
         let mut param_types = params
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -106,9 +106,9 @@ impl Function {
 
         let results = fn_ty.results();
         let mut result_types = results
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -152,7 +152,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -166,9 +166,9 @@ impl Function {
     {
         check_isolate(store);
         let mut param_types = Args::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -180,9 +180,9 @@ impl Function {
         };
 
         let mut result_types = Rets::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -224,7 +224,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -242,9 +242,9 @@ impl Function {
     {
         check_isolate(store);
         let mut param_types = Args::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -256,9 +256,9 @@ impl Function {
         };
 
         let mut result_types = Rets::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -304,7 +304,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -355,17 +355,15 @@ impl Function {
         let store_mut = store.as_store_mut();
         // let wasm_func_param_arity(self.handle)
 
-        let mut args = {
-            unsafe {
-                let mut wasm_params = params
-                    .into_iter()
-                    .map(|v| IntoCApiValue::into_cv(v.clone()))
-                    .collect::<Vec<_>>()
-                    .into_boxed_slice();
-                let mut vec = Default::default();
-                wasm_val_vec_new(&mut vec, wasm_params.len(), wasm_params.as_ptr());
-                vec
-            }
+        let 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) };
@@ -392,7 +390,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)),
                 }
@@ -404,14 +402,15 @@ impl Function {
             return Err(Into::<Trap>::into(trap).into());
         }
 
-        unsafe {
+        let values = unsafe {
             let results = std::ptr::slice_from_raw_parts(results.data, results.size);
-            return Ok((*results)
-                .into_iter()
+            (*results)
+                .iter()
                 .map(|v| IntoWasmerValue::into_wv(*v))
                 .collect::<Vec<_>>()
-                .into_boxed_slice());
-        }
+                .into_boxed_slice()
+        };
+        Ok(values)
     }
 
     pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
@@ -457,15 +456,18 @@ where
     {
         let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
 
-        let mut store = (*r).store.as_store_mut();
-        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut 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 = &(*r).func;
+        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).size {
-            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        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 {
@@ -479,13 +481,18 @@ where
                     .map(IntoCApiValue::into_cv)
                     .collect();
 
-                if c_results.len() != (*rets).size {
-                    panic!("when calling host function: number of observed results differ from wanted results")
+                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 {
-                    for i in 0..(*rets).size {
-                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    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;
                     }
                 }
 
@@ -503,7 +510,7 @@ where
         }
     }
 
-    return fn_callback::<F, T>;
+    fn_callback::<F, T>
 }
 
 impl std::fmt::Debug for Function {
@@ -555,7 +562,7 @@ macro_rules! impl_host_function {
                 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;
@@ -609,7 +616,7 @@ macro_rules! impl_host_function {
                         unimplemented!("host function panicked");
                     }
                 }
-            }
+            }}
             func_wrapper::< $( $x, )* Rets, RetsAsResult, Func> as _
         }
 
@@ -625,7 +632,7 @@ macro_rules! impl_host_function {
               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();
@@ -678,7 +685,7 @@ macro_rules! impl_host_function {
 
                 Err(e) => { unimplemented!("host function panicked"); }
               }
-            }
+            }}
 
             func_wrapper::< $( $x, )* Rets, RetsAsResult, Func, T> as _
         }
diff --git a/lib/api/src/backend/v8/entities/function/typed.rs b/lib/api/src/backend/v8/entities/function/typed.rs
index ffbe1e9a97..092b8c7316 100644
--- a/lib/api/src/backend/v8/entities/function/typed.rs
+++ b/lib/api/src/backend/v8/entities/function/typed.rs
@@ -11,9 +11,9 @@
 use std::iter::FromIterator;
 
 use crate::{
-    backend::v8::{bindings::*, error::Trap, function::Function, utils::convert::*},
     AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
     TypedFunction, Value, WasmTypeList,
+    backend::v8::{bindings::*, error::Trap, function::Function, utils::convert::*},
 };
 use wasmer_types::RawValue;
 
@@ -133,9 +133,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/v8/entities/global.rs b/lib/api/src/backend/v8/entities/global.rs
index 796047081e..35a80fb853 100644
--- a/lib/api/src/backend/v8/entities/global.rs
+++ b/lib/api/src/backend/v8/entities/global.rs
@@ -2,6 +2,7 @@
 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,
@@ -12,7 +13,6 @@ use crate::{
         vm::VMGlobal,
     },
     vm::{VMExtern, VMExternGlobal},
-    AsStoreMut, AsStoreRef, RuntimeError, Value,
 };
 
 use super::check_isolate;
diff --git a/lib/api/src/backend/v8/entities/instance.rs b/lib/api/src/backend/v8/entities/instance.rs
index 3d337a6447..02afbfb94f 100644
--- a/lib/api/src/backend/v8/entities/instance.rs
+++ b/lib/api/src/backend/v8/entities/instance.rs
@@ -2,8 +2,8 @@
 use std::sync::Arc;
 
 use crate::{
-    backend::v8::bindings::*, v8::error::Trap, vm::VMExtern, AsStoreMut, AsStoreRef, Exports,
-    Extern, Imports, InstantiationError, Module,
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
+    backend::v8::bindings::*, v8::error::Trap, vm::VMExtern,
 };
 
 use super::check_isolate;
@@ -15,6 +15,7 @@ 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,
@@ -46,7 +47,7 @@ impl InstanceHandle {
             return Err(InstantiationError::Start(trap.into()));
         }
 
-        Ok(InstanceHandle(instance))
+        Ok(Self(instance))
     }
 
     fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
@@ -61,20 +62,19 @@ impl InstanceHandle {
             unsafe { std::slice::from_raw_parts(exports.data, exports.size) };
 
         let exports_ty = module.exports().collect::<Vec<_>>();
-        let exports = exports_ty
+        exports_ty
             .iter()
-            .zip(wasm_exports.into_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();
+                let _extern_type = export_type.ty();
                 // Annotation is here to prevent spurious IDE warnings.
 
                 let extern_ = Extern::from_vm_extern(&mut store, VMExtern::V8(*wasm_export));
                 (name.to_string(), extern_)
             })
-            .collect::<Exports>();
-        exports
+            .collect::<Exports>()
     }
 }
 impl Drop for InstanceHandle {
@@ -90,6 +90,7 @@ pub struct Instance {
 }
 
 impl Instance {
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new(
         store: &mut impl AsStoreMut,
         module: &Module,
@@ -98,18 +99,19 @@ impl Instance {
         check_isolate(store);
         let mut store = store.as_store_mut();
 
-        let externs = module
+        let externs: Vec<_> = module
             .imports()
             .map(|import_ty| {
                 imports
                     .get_export(import_ty.module(), import_ty.name())
-                    .expect(format!("Export {import_ty:?} not found").as_str())
+                    .unwrap_or_else(|| panic!("Export {import_ty:?} not found"))
             })
             .collect::<Vec<_>>();
 
-        return Self::new_by_index(&mut store, module, &externs);
+        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,
diff --git a/lib/api/src/backend/v8/entities/memory/mod.rs b/lib/api/src/backend/v8/entities/memory/mod.rs
index c78874df5d..d73bc99f04 100644
--- a/lib/api/src/backend/v8/entities/memory/mod.rs
+++ b/lib/api/src/backend/v8/entities/memory/mod.rs
@@ -6,10 +6,10 @@ 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},
-    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
 };
 
 pub(crate) mod view;
@@ -188,7 +188,7 @@ impl Memory {
     /// can be put into a new store
     pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
         check_isolate(store);
-        Ok(self.handle.clone())
+        Ok(self.handle)
     }
 
     /// Copying the memory will actually copy all the bytes in the memory to
@@ -319,26 +319,36 @@ 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u64>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u32>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u16>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u8>(&mut src, &mut dst, &mut len);
+        }
     }
 }
 
@@ -346,26 +356,36 @@ unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: us
 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u64>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u32>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u16>(&mut src, &mut dst, &mut len);
+        }
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe {
+            copy_one::<u8>(&mut src, &mut dst, &mut len);
+        }
     }
 }
 
diff --git a/lib/api/src/backend/v8/entities/memory/view.rs b/lib/api/src/backend/v8/entities/memory/view.rs
index a4be3e93ed..3d516c178c 100644
--- a/lib/api/src/backend/v8/entities/memory/view.rs
+++ b/lib/api/src/backend/v8/entities/memory/view.rs
@@ -4,9 +4,9 @@ use wasmer_types::Pages;
 
 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,
-    AsStoreRef, MemoryAccessError,
 };
 
 /// A WebAssembly `memory` view.
@@ -25,7 +25,7 @@ impl<'a> MemoryView<'a> {
     pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let c_memory: *mut wasm_memory_t = memory.handle;
 
-        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let 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 _) };
 
@@ -62,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.data_unchecked_mut()
+        unsafe { self.data_unchecked_mut() }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -77,7 +77,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+        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/v8/entities/mod.rs b/lib/api/src/backend/v8/entities/mod.rs
index 9cb3801d8c..d2e8801def 100644
--- a/lib/api/src/backend/v8/entities/mod.rs
+++ b/lib/api/src/backend/v8/entities/mod.rs
@@ -10,11 +10,13 @@ pub(crate) mod store;
 pub(crate) mod table;
 pub(crate) mod tag;
 
-pub(self) fn check_isolate(store: &impl crate::AsStoreRef) {
+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!");
+        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
index 6a965dad43..87db4d5332 100644
--- a/lib/api/src/backend/v8/entities/module.rs
+++ b/lib/api/src/backend/v8/entities/module.rs
@@ -2,8 +2,8 @@
 use std::{path::Path, sync::Arc};
 
 use crate::{
-    backend::v8::bindings::*, v8::utils::convert::IntoWasmerExternType, AsEngineRef, BackendModule,
-    IntoBytes, Store,
+    AsEngineRef, BackendModule, IntoBytes, Store, backend::v8::bindings::*,
+    v8::utils::convert::IntoWasmerExternType,
 };
 
 use bytes::Bytes;
@@ -49,20 +49,20 @@ impl ModuleHandle {
         let inner = unsafe { wasm_module_new(store.as_v8().inner, &bytes as *const _) };
 
         if inner.is_null() {
-            return Err(CompileError::Validate(format!(
-                "Failed to create V8 module: null module reference returned from V8"
-            )));
+            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(format!(
-                "Failed to create V8 module: null module reference returned from V8"
-            )));
+            return Err(CompileError::Validate(
+                "Failed to create V8 module: null module reference returned from V8".to_string(),
+            ));
         }
 
-        Ok(ModuleHandle {
+        Ok(Self {
             v8_shared_module_handle: inner,
             orig_store: store,
         })
@@ -78,20 +78,21 @@ impl ModuleHandle {
         let store = Store::new(engine.clone());
         let inner = unsafe { wasm_module_deserialize(store.as_v8().inner, &bytes as *const _) };
         if inner.is_null() {
-            return Err(CompileError::Validate(format!(
+            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(format!(
-                "Failed to create V8 module: null module reference returned from V8"
-            )));
+            return Err(CompileError::Validate(
+                "Failed to create V8 module: null module reference returned from V8".to_string(),
+            ));
         }
 
-        Ok(ModuleHandle {
+        Ok(Self {
             v8_shared_module_handle: inner,
             orig_store: store,
         })
@@ -151,6 +152,7 @@ impl Module {
         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,
@@ -212,6 +214,7 @@ impl Module {
         Ok(data.into())
     }
 
+    #[allow(clippy::arc_with_non_send_sync)]
     pub unsafe fn deserialize_unchecked(
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
@@ -235,7 +238,7 @@ impl Module {
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
-        Self::deserialize_unchecked(engine, bytes)
+        unsafe { Self::deserialize_unchecked(engine, bytes) }
     }
 
     pub unsafe fn deserialize_from_file_unchecked(
@@ -243,7 +246,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(
@@ -251,7 +254,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 {
diff --git a/lib/api/src/backend/v8/entities/store/mod.rs b/lib/api/src/backend/v8/entities/store/mod.rs
index 2bf988dde7..c821e8e871 100644
--- a/lib/api/src/backend/v8/entities/store/mod.rs
+++ b/lib/api/src/backend/v8/entities/store/mod.rs
@@ -2,9 +2,9 @@
 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},
-    AsStoreRef, BackendStore, StoreRef,
 };
 
 mod obj;
@@ -29,7 +29,7 @@ impl Store {
     pub(crate) fn new(engine: crate::engine::Engine) -> Self {
         let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_v8().inner.engine) };
         let thread_id = std::thread::current().id();
-        Store {
+        Self {
             inner,
             engine,
             thread_id,
diff --git a/lib/api/src/backend/v8/entities/store/obj.rs b/lib/api/src/backend/v8/entities/store/obj.rs
index 6f69a2d99f..fbfb0dd901 100644
--- a/lib/api/src/backend/v8/entities/store/obj.rs
+++ b/lib/api/src/backend/v8/entities/store/obj.rs
@@ -1,8 +1,8 @@
 use std::{fmt, marker::PhantomData, num::NonZeroUsize};
 
 use crate::{
-    backend::v8::vm::{VMFunctionEnvironment, VMGlobal},
     AsStoreMut,
+    backend::v8::vm::{VMFunctionEnvironment, VMGlobal},
 };
 
 pub use wasmer_types::StoreId;
@@ -11,7 +11,7 @@ impl crate::StoreObjects {
     /// Consume [`self`] into [`crate::backend::v8::store::StoreObjects`].
     pub fn into_v8(self) -> crate::backend::v8::store::StoreObjects {
         match self {
-            crate::StoreObjects::V8(s) => s,
+            Self::V8(s) => s,
             _ => panic!("Not a `v8` store!"),
         }
     }
@@ -19,7 +19,7 @@ impl crate::StoreObjects {
     /// Convert a reference to [`self`] into a reference [`crate::backend::v8::store::StoreObjects`].
     pub fn as_v8(&self) -> &crate::backend::v8::store::StoreObjects {
         match self {
-            crate::StoreObjects::V8(s) => s,
+            Self::V8(s) => s,
             _ => panic!("Not a `v8` store!"),
         }
     }
@@ -27,7 +27,7 @@ impl crate::StoreObjects {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::store::StoreObjects`].
     pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::store::StoreObjects {
         match self {
-            crate::StoreObjects::V8(s) => s,
+            Self::V8(s) => s,
             _ => panic!("Not a `v8` store!"),
         }
     }
@@ -107,7 +107,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+    pub fn iter_globals<'a>(&'a self) -> core::slice::Iter<'a, VMGlobal> {
         self.globals.iter()
     }
 
diff --git a/lib/api/src/backend/v8/entities/table.rs b/lib/api/src/backend/v8/entities/table.rs
index 30ff4465cb..d3053c221c 100644
--- a/lib/api/src/backend/v8/entities/table.rs
+++ b/lib/api/src/backend/v8/entities/table.rs
@@ -2,13 +2,13 @@
 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},
-    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
 };
 
 use super::check_isolate;
@@ -28,10 +28,7 @@ impl Table {
 
         let limits = Box::into_raw(Box::new(wasm_limits_t {
             min: ty.minimum,
-            max: match ty.maximum {
-                Some(v) => v,
-                None => 0,
-            },
+            max: ty.maximum.unwrap_or_default(),
             shared: false,
         }));
 
@@ -125,7 +122,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {val:?} "
-                    )))
+                    )));
                 }
             };
 
@@ -162,7 +159,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {init:?} "
-                    )))
+                    )));
                 }
             };
             if !wasm_table_grow(self.handle, delta, init) {
@@ -210,16 +207,16 @@ impl crate::Table {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::v8::table::Table`].
     pub fn as_v8(&self) -> &crate::backend::v8::table::Table {
-        match self.0 {
-            BackendTable::V8(ref s) => s,
+        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 self.0 {
-            BackendTable::V8(ref mut s) => s,
+        match &mut self.0 {
+            BackendTable::V8(s) => s,
             _ => panic!("Not a `v8` table!"),
         }
     }
@@ -237,7 +234,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::v8::table::Table`].
     pub fn as_v8(&self) -> &crate::backend::v8::table::Table {
         match self {
-            Self::V8(ref s) => s,
+            Self::V8(s) => s,
             _ => panic!("Not a `v8` table!"),
         }
     }
@@ -245,7 +242,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::table::Table`].
     pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::table::Table {
         match self {
-            Self::V8(ref mut s) => s,
+            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
index bc2aeeb9f7..2672dfc323 100644
--- a/lib/api/src/backend/v8/entities/tag.rs
+++ b/lib/api/src/backend/v8/entities/tag.rs
@@ -2,13 +2,13 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef,
     v8::{
         bindings::*,
         utils::convert::{IntoCApiType, IntoWasmerType},
         vm::VMTag,
     },
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef,
 };
 
 use super::check_isolate;
diff --git a/lib/api/src/backend/v8/error.rs b/lib/api/src/backend/v8/error.rs
index 7f9b26e98a..6065ffea37 100644
--- a/lib/api/src/backend/v8/error.rs
+++ b/lib/api/src/backend/v8/error.rs
@@ -1,9 +1,12 @@
 use std::{
     error::Error,
-    ffi::{c_char, CStr},
+    ffi::{CStr, c_char},
 };
 
-use crate::{v8::bindings::*, AsStoreMut};
+use crate::{
+    AsStoreMut,
+    v8::{bindings::*, vm::VMExceptionRef},
+};
 
 #[derive(Debug)]
 enum InnerTrap {
@@ -53,19 +56,30 @@ impl Trap {
         }
     }
 
+    /// 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 = std::mem::zeroed();
+                let mut data = unsafe { std::mem::zeroed() };
                 // let x = format!("")
                 let s1 = format!("🐛{err_ptr:p}");
                 let _s = s1.into_bytes().into_boxed_slice();
-                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                unsafe { wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _) };
                 std::mem::forget(_s);
                 let store = store.as_store_mut();
-                wasm_trap_new(store.inner.store.as_v8().inner, &mut data)
+                unsafe { wasm_trap_new(store.inner.store.as_v8().inner, &mut data) }
             }
         }
     }
@@ -82,8 +96,8 @@ impl Trap {
 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);
+            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()
@@ -94,10 +108,8 @@ impl From<*mut wasm_trap_t> for Trap {
             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>),
-                )
+                std::ptr::read(usize::from_str_radix(r, 16).unwrap()
+                    as *const Box<dyn Error + Send + Sync + 'static>)
             };
 
             Self {
@@ -146,6 +158,6 @@ impl From<Trap> for crate::RuntimeError {
             return trap.downcast::<Self>().unwrap();
         }
 
-        crate::RuntimeError::new_from_source(crate::BackendTrap::V8(trap), vec![], None)
+        Self::new_from_source(crate::BackendTrap::V8(trap), vec![], None)
     }
 }
diff --git a/lib/api/src/backend/v8/utils/convert.rs b/lib/api/src/backend/v8/utils/convert.rs
index d7540b264a..126fd34dad 100644
--- a/lib/api/src/backend/v8/utils/convert.rs
+++ b/lib/api/src/backend/v8/utils/convert.rs
@@ -2,11 +2,11 @@ use wasmer_types::{ExternType, FunctionType, Mutability, Type};
 
 /// Utilities to convert between `v8` and `wasmer` values
 use crate::{
+    BackendFunction, Function, Value,
     v8::{
         bindings::{self, *},
         function,
     },
-    BackendFunction, Function, Value,
 };
 
 pub trait IntoCApiValue {
@@ -17,41 +17,41 @@ pub trait IntoCApiValue {
 impl IntoCApiValue for Value {
     fn into_cv(self) -> wasm_val_t {
         match self {
-            Value::I32(val) => wasm_val_t {
+            Self::I32(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_I32 as _,
                 of: wasm_val_t__bindgen_ty_1 { i32_: val },
             },
-            Value::I64(val) => wasm_val_t {
+            Self::I64(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_I64 as _,
                 of: wasm_val_t__bindgen_ty_1 { i64_: val },
             },
-            Value::F32(val) => wasm_val_t {
+            Self::F32(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_F32 as _,
                 of: wasm_val_t__bindgen_ty_1 { f32_: val },
             },
-            Value::F64(val) => wasm_val_t {
+            Self::F64(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_F64 as _,
                 of: wasm_val_t__bindgen_ty_1 { f64_: val },
             },
-            Value::FuncRef(Some(val)) => wasm_val_t {
+            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) },
                 },
             },
-            Value::FuncRef(None) => wasm_val_t {
+            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()) },
                 },
             },
-            Value::ExternRef(_) => panic!(
+            Self::ExternRef(_) => panic!(
                 "Creating host values from guest ExternRefs is not currently supported in V8."
             ),
-            Value::ExceptionRef(_) => {
+            Self::ExceptionRef(_) => {
                 panic!("Creating host values from guest V128s is not currently supported in V8.")
             }
-            Value::V128(_) => {
+            Self::V128(_) => {
                 panic!("Creating host values from guest V128s is not currently supported in V8.")
             }
         }
@@ -110,14 +110,14 @@ pub trait IntoCApiType {
 impl IntoCApiType for Type {
     fn into_ct(self) -> wasm_valkind_t {
         match self as _ {
-            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
-            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
-            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
-            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
-            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
-            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
-            Type::V128 => panic!("v8 currently does not support V128 types"),
-            Type::ExceptionRef => panic!("v8 currently does not support exnrefs"),
+            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"),
         }
     }
 }
@@ -150,13 +150,13 @@ pub trait IntoWasmerExternType {
 
 impl IntoWasmerExternType for wasm_externtype_t {
     unsafe fn into_wextt(mut self) -> Result<ExternType, String> {
-        (&self as *const wasm_externtype_t).into_wextt()
+        unsafe { (&self as *const Self).into_wextt() }
     }
 }
 
 impl IntoWasmerExternType for *mut wasm_externtype_t {
     unsafe fn into_wextt(self) -> Result<ExternType, String> {
-        (self as *const wasm_externtype_t).into_wextt()
+        unsafe { (self as *const wasm_externtype_t).into_wextt() }
     }
 }
 
diff --git a/lib/api/src/backend/v8/vm/mod.rs b/lib/api/src/backend/v8/vm/mod.rs
index 4c11590ec9..7c798c2589 100644
--- a/lib/api/src/backend/v8/vm/mod.rs
+++ b/lib/api/src/backend/v8/vm/mod.rs
@@ -38,6 +38,7 @@ 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) };
@@ -132,7 +133,7 @@ impl VMFuncRef {
     }
 }
 
-pub(crate) struct VMExceptionRef(*mut wasm_ref_t);
+pub struct VMExceptionRef(*mut wasm_ref_t);
 impl VMExceptionRef {
     /// Converts the `VMExceptionRef` into a `RawValue`.
     pub fn into_raw(self) -> RawValue {
diff --git a/lib/api/src/backend/wamr/entities/engine.rs b/lib/api/src/backend/wamr/entities/engine.rs
index 6e30b96cf3..27fc6301fd 100644
--- a/lib/api/src/backend/wamr/entities/engine.rs
+++ b/lib/api/src/backend/wamr/entities/engine.rs
@@ -1,10 +1,10 @@
 //! Data types, functions and traits for `wamr` runtime's `Engine` implementation.
 use crate::{
-    backend::wamr::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
     BackendEngine,
+    backend::wamr::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
 };
 use std::sync::Arc;
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 #[derive(Debug)]
 pub(crate) struct CApiEngine {
@@ -86,8 +86,8 @@ impl crate::Engine {
 
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::engine::Engine`].
     pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::engine::Engine {
-        match self.be {
-            BackendEngine::Wamr(ref mut s) => s,
+        match &mut self.be {
+            BackendEngine::Wamr(s) => s,
             _ => panic!("Not a `wamr` engine!"),
         }
     }
@@ -100,9 +100,9 @@ impl crate::Engine {
 
 impl From<Engine> for crate::Engine {
     fn from(value: Engine) -> Self {
-        crate::Engine {
+        Self {
             be: BackendEngine::Wamr(value),
-            id: crate::Engine::atomic_next_engine_id(),
+            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
index 437511562a..ef1db7b6a8 100644
--- a/lib/api/src/backend/wamr/entities/exception.rs
+++ b/lib/api/src/backend/wamr/entities/exception.rs
@@ -4,8 +4,8 @@ use std::any::Any;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    wamr::vm::{VMException, VMExceptionRef},
     AsStoreMut, AsStoreRef, Tag, Value,
+    wamr::vm::{VMException, VMExceptionRef},
 };
 
 use super::store::StoreHandle;
@@ -22,42 +22,6 @@ unsafe impl Sync for Exception {}
 impl Exception {
     /// Create a new [`Exception`].
     pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `extern ref` in `wamr`.
-pub(crate) struct ExceptionRef;
-
-impl ExceptionRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in wamr");
-    }
-
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in wamr");
-    }
-
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        unimplemented!("ExceptionRef is not yet supported in wamr");
-    }
-
-    pub(crate) unsafe fn from_vm_exceptionref(
-        _store: &mut impl AsStoreMut,
-        _vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        unimplemented!("ExceptionRef is not yet supported in wamr");
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+        unimplemented!("Exception handling is not yet supported in wamr");
     }
 }
diff --git a/lib/api/src/backend/wamr/entities/function/env.rs b/lib/api/src/backend/wamr/entities/function/env.rs
index 266022b205..9614a6f1a6 100644
--- a/lib/api/src/backend/wamr/entities/function/env.rs
+++ b/lib/api/src/backend/wamr/entities/function/env.rs
@@ -1,9 +1,9 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
 use crate::{
+    StoreMut,
     store::{AsStoreMut, AsStoreRef, StoreRef},
     wamr::{store::StoreHandle, vm::VMFunctionEnvironment},
-    StoreMut,
 };
 
 #[derive(Debug)]
@@ -62,7 +62,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// 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,
     {
@@ -137,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
@@ -185,16 +185,16 @@ impl<T> crate::FunctionEnv<T> {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::function::env::FunctionEnv`].
     pub fn as_wamr(&self) -> &FunctionEnv<T> {
-        match self.0 {
-            crate::BackendFunctionEnv::Wamr(ref s) => s,
+        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 self.0 {
-            crate::BackendFunctionEnv::Wamr(ref mut s) => s,
+        match &mut self.0 {
+            crate::BackendFunctionEnv::Wamr(s) => s,
             _ => panic!("Not a `wamr` function env!"),
         }
     }
@@ -202,12 +202,12 @@ impl<T> crate::FunctionEnv<T> {
 
 impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
     fn from(value: FunctionEnvMut<'a, T>) -> Self {
-        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Wamr(value))
+        Self(crate::BackendFunctionEnvMut::Wamr(value))
     }
 }
 
 impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
     fn from(value: FunctionEnv<T>) -> Self {
-        crate::FunctionEnv(crate::BackendFunctionEnv::Wamr(value))
+        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
index 3e4bbf6605..903cbad702 100644
--- a/lib/api/src/backend/wamr/entities/function/mod.rs
+++ b/lib/api/src/backend/wamr/entities/function/mod.rs
@@ -7,15 +7,15 @@ use std::{
 };
 
 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},
     },
-    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
-    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
-    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
 };
 
 use super::{super::error::Trap, store::StoreHandle};
@@ -90,7 +90,8 @@ impl Function {
         let params = fn_ty.params();
 
         let mut param_types = params
-            .into_iter()
+            .iter()
+            .cloned()
             .map(|param| {
                 let kind = param.into_ct();
                 unsafe { wasm_valtype_new(kind) }
@@ -105,7 +106,8 @@ impl Function {
 
         let results = fn_ty.results();
         let mut result_types = results
-            .into_iter()
+            .iter()
+            .cloned()
             .map(|param| {
                 let kind = param.into_ct();
                 unsafe { wasm_valtype_new(kind) }
@@ -151,7 +153,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -163,8 +165,10 @@ impl Function {
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
-        let mut param_types = Args::wasm_types()
-            .into_iter()
+        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) }
@@ -177,8 +181,10 @@ impl Function {
             vec
         };
 
-        let mut result_types = Rets::wasm_types()
-            .into_iter()
+        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) }
@@ -222,7 +228,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -238,8 +244,10 @@ impl Function {
         Rets: WasmTypeList,
         T: Send + 'static,
     {
-        let mut param_types = Args::wasm_types()
-            .into_iter()
+        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) }
@@ -252,8 +260,10 @@ impl Function {
             vec
         };
 
-        let mut result_types = Rets::wasm_types()
-            .into_iter()
+        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) }
@@ -301,7 +311,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -350,17 +360,16 @@ impl Function {
         let store_mut = store.as_store_mut();
         // let wasm_func_param_arity(self.handle)
 
-        let mut args = {
-            unsafe {
-                let mut wasm_params = params
-                    .into_iter()
-                    .map(|v| IntoCApiValue::into_cv(v.clone()))
-                    .collect::<Vec<_>>()
-                    .into_boxed_slice();
-                let mut vec = Default::default();
-                wasm_val_vec_new(&mut vec, wasm_params.len(), wasm_params.as_ptr());
-                vec
-            }
+        let 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) };
@@ -387,7 +396,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)),
                 }
@@ -399,14 +408,12 @@ impl Function {
             return Err(Into::<Trap>::into(trap).into());
         }
 
-        unsafe {
-            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
-            return Ok((*results)
-                .into_iter()
-                .map(|v| IntoWasmerValue::into_wv(*v))
-                .collect::<Vec<_>>()
-                .into_boxed_slice());
-        }
+        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 {
@@ -452,15 +459,16 @@ where
     {
         let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
 
-        let mut store = (*r).store.as_store_mut();
-        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut 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 = &(*r).func;
+        let func: &F = unsafe { &(*r).func };
 
         let mut wasmer_args = vec![];
 
-        for i in 0..(*args).size {
-            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        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 {
@@ -474,13 +482,16 @@ where
                     .map(IntoCApiValue::into_cv)
                     .collect();
 
-                if c_results.len() != (*rets).size {
-                    panic!("when calling host function: number of observed results differ from wanted results")
+                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 in 0..(*rets).size {
-                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    for (i, value) in c_results.iter().enumerate() {
+                        *(*rets).data.wrapping_add(i) = *value;
                     }
                 }
 
@@ -498,7 +509,7 @@ where
         }
     }
 
-    return fn_callback::<F, T>;
+    fn_callback::<F, T>
 }
 
 impl std::fmt::Debug for Function {
@@ -518,16 +529,16 @@ impl crate::Function {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::function::Function`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::function::Function {
-        match self.0 {
-            BackendFunction::Wamr(ref s) => s,
+        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 self.0 {
-            BackendFunction::Wamr(ref mut s) => s,
+        match &mut self.0 {
+            BackendFunction::Wamr(s) => s,
             _ => panic!("Not a `wamr` function!"),
         }
     }
@@ -551,43 +562,48 @@ macro_rules! impl_host_function {
                 RetsAsResult: IntoResult<Rets>,
                 Func: Fn($( $x , )*) -> RetsAsResult + 'static,
             {
-                let mut r: *mut crate::backend::wamr::function::FunctionCallbackEnv<Func> = unsafe {std::mem::transmute(env)};
-                let store = &mut (*r).store.as_store_mut();
+                let 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 = (*(*args).data.wrapping_add(i)).clone();
+                    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(store);
-                    let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+                    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 result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
-                    ((*r).func)( $( $x, )* ).into_result()
+                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 = result.into_array(store);
+                        let mut native_results = unsafe { result.into_array(&mut 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()))
+                        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();
 
-                        if c_results.len() != (*results).size {
+                        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 in 0..(*results).size {
-                                *((*results).data.wrapping_add(i)) = c_results[i]
+                            for (i, value) in c_results.iter().enumerate() {
+                                *(*results).data.wrapping_add(i) = *value;
                             }
                         }
 
@@ -596,7 +612,7 @@ macro_rules! impl_host_function {
 
                     Ok(Err(e)) => {
                         let trap =  crate::backend::wamr::error::Trap::user(Box::new(e));
-                        unsafe { trap.into_wasm_trap(store) }
+                        unsafe { trap.into_wasm_trap(&mut store) }
                         // unimplemented!("host function panicked");
                     },
 
@@ -623,45 +639,53 @@ macro_rules! impl_host_function {
             {
 
 	          let r: *mut (crate::backend::wamr::function::FunctionCallbackEnv<'_, Func>) = env as _;
-	          let store = &mut (*r).store.as_store_mut();
+	          let mut store = unsafe { (*r).store.as_store_mut() };
 
 	          let mut i = 0;
 
 	          $(
-	          let c_arg = (*(*args).data.wrapping_add(i)).clone();
+	          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(store);
-	          let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+	          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 = (*r).env_handle.as_ref().unwrap().clone();
-	          let mut fn_env = crate::backend::wamr::function::env::FunctionEnv::from_handle(env_handle).into_mut(store);
-	          let func: &Func = &(*r).func;
+	          let 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(|| unsafe {
-	              ((*r).func)(BackendFunctionEnvMut::Wamr(fn_env).into(), $( $x, )* ).into_result()
+	          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 = result.into_array(store);
+	          	  let mut native_results = unsafe { result.into_array(&mut 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 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();
 
-	          	  if c_results.len() != (*results).size {
+	          	  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 in 0..(*results).size {
-	          	          *((*results).data.wrapping_add(i)) = c_results[i]
+	          	      for (i, value) in c_results.iter().enumerate() {
+	          	          *(*results).data.wrapping_add(i) = *value;
 	          	      }
 
 	          	  }
@@ -669,7 +693,7 @@ macro_rules! impl_host_function {
 	          	  unsafe { std::ptr::null_mut() }
 	            },
 
-	            Ok(Err(e)) => { let trap = crate::backend::wamr::error::Trap::user(Box::new(e)); unsafe { trap.into_wasm_trap(store) } },
+	            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"); }
 	          }
diff --git a/lib/api/src/backend/wamr/entities/function/typed.rs b/lib/api/src/backend/wamr/entities/function/typed.rs
index c40acd82cb..388db3d690 100644
--- a/lib/api/src/backend/wamr/entities/function/typed.rs
+++ b/lib/api/src/backend/wamr/entities/function/typed.rs
@@ -11,9 +11,9 @@
 use std::iter::FromIterator;
 
 use crate::{
-    backend::wamr::{bindings::*, error::Trap, function::Function, utils::convert::*},
     AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
     TypedFunction, Value, WasmTypeList,
+    backend::wamr::{bindings::*, error::Trap, function::Function, utils::convert::*},
 };
 use wasmer_types::RawValue;
 
@@ -133,9 +133,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/wamr/entities/global.rs b/lib/api/src/backend/wamr/entities/global.rs
index 51ae7c87ae..7d7efd9c1b 100644
--- a/lib/api/src/backend/wamr/entities/global.rs
+++ b/lib/api/src/backend/wamr/entities/global.rs
@@ -2,6 +2,7 @@
 use wasmer_types::{GlobalType, Mutability};
 
 use crate::{
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
     vm::{VMExtern, VMExternGlobal},
     wamr::{
         bindings::{
@@ -12,7 +13,6 @@ use crate::{
         utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
         vm::VMGlobal,
     },
-    AsStoreMut, AsStoreRef, RuntimeError, Value,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/wamr/entities/instance.rs b/lib/api/src/backend/wamr/entities/instance.rs
index 30a61b39d0..188c5bccb4 100644
--- a/lib/api/src/backend/wamr/entities/instance.rs
+++ b/lib/api/src/backend/wamr/entities/instance.rs
@@ -3,8 +3,8 @@ use std::sync::Arc;
 
 use crate::entities::external::VMExternToExtern;
 use crate::{
-    backend::wamr::bindings::*, vm::VMExtern, wamr::error::Trap, AsStoreMut, AsStoreRef, Exports,
-    Extern, Imports, InstantiationError, Module,
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
+    backend::wamr::bindings::*, vm::VMExtern, wamr::error::Trap,
 };
 
 #[derive(PartialEq, Eq)]
@@ -14,6 +14,7 @@ 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,
@@ -40,7 +41,7 @@ impl InstanceHandle {
 
             std::mem::forget(externs);
 
-            wasm_instance_new(store, module, &mut imports, &mut trap)
+            wasm_instance_new(store, module, &imports, &mut trap)
         };
 
         if instance.is_null() {
@@ -48,7 +49,7 @@ impl InstanceHandle {
             return Err(InstantiationError::Start(trap.into()));
         }
 
-        Ok(InstanceHandle(instance))
+        Ok(Self(instance))
     }
 
     fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
@@ -66,7 +67,6 @@ impl InstanceHandle {
         } else {
             unsafe { std::slice::from_raw_parts(c_api_externs.data, c_api_externs.size) }.to_vec()
         };
-        let c_api_externs = c_api_externs.to_vec();
         let mut exports = unsafe {
             let mut vec = Default::default();
             wasm_module_exports(module.as_wamr().handle.inner, &mut vec);
@@ -86,7 +86,7 @@ impl InstanceHandle {
 
         let c_api_exports: Exports = c_api_exports
             .into_iter()
-            .zip(c_api_externs.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);
@@ -104,10 +104,7 @@ impl InstanceHandle {
         for e in module_exports {
             let ext: Extern = c_api_exports
                 .get::<Extern>(e.name())
-                .expect(&format!(
-                    "c_api_exports: {c_api_exports:?} (name: {})",
-                    e.name()
-                ))
+                .unwrap_or_else(|_| panic!("c_api_exports: {c_api_exports:?} (name: {})", e.name()))
                 .clone();
             exports.insert(e.name().to_string(), ext);
         }
@@ -128,6 +125,7 @@ pub struct Instance {
 }
 
 impl Instance {
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new(
         store: &mut impl AsStoreMut,
         module: &Module,
@@ -148,9 +146,10 @@ impl Instance {
         let mut store_from_module = wamr_module.handle.store.lock().unwrap();
         let mut store = store_from_module.as_store_mut();
 
-        return Self::new_by_index(&mut store, module, &externs);
+        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,
diff --git a/lib/api/src/backend/wamr/entities/memory/mod.rs b/lib/api/src/backend/wamr/entities/memory/mod.rs
index c6d2eec24f..ecd177f4d4 100644
--- a/lib/api/src/backend/wamr/entities/memory/mod.rs
+++ b/lib/api/src/backend/wamr/entities/memory/mod.rs
@@ -7,10 +7,10 @@ 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},
-    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
 };
 
 pub(crate) mod view;
@@ -152,7 +152,7 @@ impl Memory {
     /// Cloning memory will create another reference to the same memory that
     /// can be put into a new store
     pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        Ok(self.handle.clone())
+        Ok(self.handle)
     }
 
     /// Copying the memory will actually copy all the bytes in the memory to
@@ -280,26 +280,26 @@ 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u8>(&mut src, &mut dst, &mut len) };
     }
 }
 
@@ -307,26 +307,26 @@ unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: us
 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u8>(&mut src, &mut dst, &mut len) };
     }
 }
 
@@ -341,16 +341,16 @@ impl crate::Memory {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::memory::Memory`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::memory::Memory {
-        match self.0 {
-            BackendMemory::Wamr(ref s) => s,
+        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 self.0 {
-            BackendMemory::Wamr(ref mut s) => s,
+        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
index 206c1a0f15..e9678e8753 100644
--- a/lib/api/src/backend/wamr/entities/memory/view.rs
+++ b/lib/api/src/backend/wamr/entities/memory/view.rs
@@ -4,9 +4,9 @@ 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,
-    AsStoreRef, MemoryAccessError,
 };
 
 /// A WebAssembly `memory` view.
@@ -25,7 +25,7 @@ impl<'a> MemoryView<'a> {
     pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let c_memory: *mut wasm_memory_t = memory.handle;
 
-        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let 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 _) };
 
@@ -62,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.data_unchecked_mut()
+        unsafe { self.data_unchecked_mut() }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -77,7 +77,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+        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/wamr/entities/module.rs b/lib/api/src/backend/wamr/entities/module.rs
index 0b12f36c54..830c7d8709 100644
--- a/lib/api/src/backend/wamr/entities/module.rs
+++ b/lib/api/src/backend/wamr/entities/module.rs
@@ -1,7 +1,7 @@
 //! Data types, functions and traits for `wamr`'s `Module` implementation.
 use std::{path::Path, sync::Arc};
 
-use crate::{backend::wamr::bindings::*, AsEngineRef, BackendModule, IntoBytes};
+use crate::{AsEngineRef, BackendModule, IntoBytes, backend::wamr::bindings::*};
 
 use bytes::Bytes;
 use wasmer_types::{
@@ -14,6 +14,9 @@ pub(crate) struct ModuleHandle {
     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
@@ -40,10 +43,10 @@ impl ModuleHandle {
         let store = std::sync::Mutex::new(store);
 
         if inner.is_null() {
-            return Err(CompileError::Validate(format!("module is null")));
+            return Err(CompileError::Validate("module is null".to_string()));
         }
 
-        Ok(ModuleHandle { inner, store })
+        Ok(Self { inner, store })
     }
 }
 impl Drop for ModuleHandle {
@@ -118,24 +121,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(
@@ -143,7 +145,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(
@@ -151,7 +153,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 {
@@ -190,16 +192,16 @@ impl crate::Module {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::module::Module`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::module::Module {
-        match self.0 {
-            BackendModule::Wamr(ref s) => s,
+        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 self.0 {
-            BackendModule::Wamr(ref mut s) => s,
+        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
index 2e556e16bf..cc18d07cc8 100644
--- a/lib/api/src/backend/wamr/entities/store/mod.rs
+++ b/lib/api/src/backend/wamr/entities/store/mod.rs
@@ -1,8 +1,8 @@
 //! 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},
-    AsStoreRef, BackendStore, StoreRef,
 };
 
 mod obj;
@@ -25,7 +25,7 @@ impl std::fmt::Debug for Store {
 impl Store {
     pub(crate) fn new(engine: crate::engine::Engine) -> Self {
         let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_wamr().inner.engine) };
-        Store { inner, engine }
+        Self { inner, engine }
     }
 
     pub(crate) fn engine(&self) -> &Engine {
diff --git a/lib/api/src/backend/wamr/entities/store/obj.rs b/lib/api/src/backend/wamr/entities/store/obj.rs
index 9c35d5fa57..bf24fb7a34 100644
--- a/lib/api/src/backend/wamr/entities/store/obj.rs
+++ b/lib/api/src/backend/wamr/entities/store/obj.rs
@@ -1,8 +1,8 @@
 use std::{fmt, marker::PhantomData, num::NonZeroUsize};
 
 use crate::{
-    backend::wamr::vm::{VMFunctionEnvironment, VMGlobal},
     AsStoreMut,
+    backend::wamr::vm::{VMFunctionEnvironment, VMGlobal},
 };
 
 pub use wasmer_types::StoreId;
@@ -11,7 +11,7 @@ impl crate::StoreObjects {
     /// Consume [`self`] into [`crate::backend::wamr::store::StoreObjects`].
     pub fn into_wamr(self) -> crate::backend::wamr::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wamr(s) => s,
+            Self::Wamr(s) => s,
             _ => panic!("Not a `wamr` store!"),
         }
     }
@@ -19,7 +19,7 @@ impl crate::StoreObjects {
     /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::store::StoreObjects`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wamr(s) => s,
+            Self::Wamr(s) => s,
             _ => panic!("Not a `wamr` store!"),
         }
     }
@@ -27,7 +27,7 @@ impl crate::StoreObjects {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::store::StoreObjects`].
     pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wamr(s) => s,
+            Self::Wamr(s) => s,
             _ => panic!("Not a `wamr` store!"),
         }
     }
@@ -107,7 +107,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+    pub fn iter_globals(&self) -> core::slice::Iter<'_, VMGlobal> {
         self.globals.iter()
     }
 
diff --git a/lib/api/src/backend/wamr/entities/table.rs b/lib/api/src/backend/wamr/entities/table.rs
index 79b05764d4..740b5df373 100644
--- a/lib/api/src/backend/wamr/entities/table.rs
+++ b/lib/api/src/backend/wamr/entities/table.rs
@@ -2,13 +2,13 @@
 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,
     },
-    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -26,10 +26,7 @@ impl Table {
 
         let limits = Box::into_raw(Box::new(wasm_limits_t {
             min: ty.minimum,
-            max: match ty.maximum {
-                Some(v) => v,
-                None => 0,
-            },
+            max: ty.maximum.unwrap_or_default(),
         }));
 
         unsafe { wasm_tabletype_new(valtype, limits) }
@@ -116,7 +113,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {val:?} "
-                    )))
+                    )));
                 }
             };
 
@@ -148,7 +145,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {init:?} "
-                    )))
+                    )));
                 }
             };
             if !wasm_table_grow(self.handle, delta, init) {
@@ -192,16 +189,16 @@ impl crate::Table {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::table::Table`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::table::Table {
-        match self.0 {
-            BackendTable::Wamr(ref s) => s,
+        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 self.0 {
-            BackendTable::Wamr(ref mut s) => s,
+        match &mut self.0 {
+            BackendTable::Wamr(s) => s,
             _ => panic!("Not a `wamr` table!"),
         }
     }
@@ -219,7 +216,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::table::Table`].
     pub fn as_wamr(&self) -> &crate::backend::wamr::table::Table {
         match self {
-            Self::Wamr(ref s) => s,
+            Self::Wamr(s) => s,
             _ => panic!("Not a `wamr` table!"),
         }
     }
@@ -227,7 +224,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::table::Table`].
     pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::table::Table {
         match self {
-            Self::Wamr(ref mut s) => s,
+            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
index d7daa2274f..def86e2c94 100644
--- a/lib/api/src/backend/wamr/entities/tag.rs
+++ b/lib/api/src/backend/wamr/entities/tag.rs
@@ -2,9 +2,9 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef,
     vm::{VMExtern, VMExternTag},
     wamr::vm::VMTag,
-    AsStoreMut, AsStoreRef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/wamr/error.rs b/lib/api/src/backend/wamr/error.rs
index 4d1b7790d5..5d80a671e3 100644
--- a/lib/api/src/backend/wamr/error.rs
+++ b/lib/api/src/backend/wamr/error.rs
@@ -1,9 +1,12 @@
 use std::{
     error::Error,
-    ffi::{c_char, CStr},
+    ffi::{CStr, c_char},
 };
 
-use crate::{wamr::bindings::*, AsStoreMut};
+use crate::{
+    AsStoreMut,
+    wamr::{bindings::*, vm::VMExceptionRef},
+};
 
 #[derive(Debug)]
 enum InnerTrap {
@@ -52,19 +55,29 @@ impl Trap {
         }
     }
 
+    /// 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 = std::mem::zeroed();
+                let mut data = unsafe { std::mem::zeroed() };
                 // let x = format!("")
-                let s1 = format!("🐛{:p}", err_ptr);
+                let s1 = format!("🐛{err_ptr:p}");
                 let _s = s1.into_bytes().into_boxed_slice();
-                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                unsafe { wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _) };
                 std::mem::forget(_s);
                 let store = store.as_store_mut();
-                wasm_trap_new(store.inner.store.as_wamr().inner, &mut data)
+                unsafe { wasm_trap_new(store.inner.store.as_wamr().inner, &data) }
             }
         }
     }
@@ -89,16 +102,13 @@ impl From<*mut wasm_trap_t> for Trap {
                 .unwrap()
         };
 
-        println!("{message}");
-
         if message.starts_with("Exception: 🐛") {
             let ptr_str = message.replace("Exception: 🐛", "");
             let ptr: Box<dyn Error + Send + Sync + 'static> = unsafe {
                 let r = ptr_str.trim_start_matches("0x");
-                std::ptr::read(
-                    (usize::from_str_radix(&r, 16).unwrap()
-                        as *const Box<dyn Error + Send + Sync + 'static>),
-                )
+                let raw_ptr = usize::from_str_radix(r, 16).unwrap()
+                    as *const Box<dyn Error + Send + Sync + 'static>;
+                std::ptr::read(raw_ptr)
             };
 
             Self {
@@ -124,18 +134,19 @@ impl std::error::Error for Trap {
 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::User(e) => write!(f, "{e}"),
             InnerTrap::CApi(value) => {
                 // let message: wasm_message_t;
                 // wasm_trap_message(value, &mut message);
-                let mut out = unsafe {
+                let message = unsafe {
                     let mut vec: wasm_byte_vec_t = Default::default();
                     wasm_byte_vec_new_empty(&mut vec);
-                    &mut vec as *mut _
+                    let out = &mut vec as *mut _;
+                    wasm_trap_message(*value, out);
+                    let cstr = CStr::from_ptr((*out).data);
+                    cstr.to_str().unwrap().to_string()
                 };
-                unsafe { wasm_trap_message(*value, out) };
-                let cstr = unsafe { CStr::from_ptr((*out).data) };
-                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+                write!(f, "wasm-c-api trap: {message}")
             }
         }
     }
@@ -144,18 +155,19 @@ impl std::fmt::Display for Trap {
 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::User(e) => write!(f, "{e}"),
             InnerTrap::CApi(value) => {
                 // let message: wasm_message_t;
                 // wasm_trap_message(value, &mut message);
-                let mut out = unsafe {
+                let message = unsafe {
                     let mut vec: wasm_byte_vec_t = Default::default();
                     wasm_byte_vec_new_empty(&mut vec);
-                    &mut vec as *mut _
+                    let out = &mut vec as *mut _;
+                    wasm_trap_message(*value, out);
+                    let cstr = CStr::from_ptr((*out).data);
+                    cstr.to_str().unwrap().to_string()
                 };
-                unsafe { wasm_trap_message(*value, out) };
-                let cstr = unsafe { CStr::from_ptr((*out).data) };
-                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+                write!(f, "wasm-c-api trap: {message}")
             }
         }
     }
@@ -167,6 +179,6 @@ impl From<Trap> for crate::RuntimeError {
             return trap.downcast::<Self>().unwrap();
         }
 
-        crate::RuntimeError::new_from_source(crate::BackendTrap::Wamr(trap), vec![], None)
+        Self::new_from_source(crate::BackendTrap::Wamr(trap), vec![], None)
     }
 }
diff --git a/lib/api/src/backend/wamr/utils/convert.rs b/lib/api/src/backend/wamr/utils/convert.rs
index 484baeba3e..8aa8c39369 100644
--- a/lib/api/src/backend/wamr/utils/convert.rs
+++ b/lib/api/src/backend/wamr/utils/convert.rs
@@ -1,5 +1,6 @@
 /// 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,
@@ -7,7 +8,6 @@ use crate::{
         },
         function,
     },
-    BackendFunction, Function, Value,
 };
 use wasmer_types::Type;
 
@@ -19,47 +19,47 @@ pub trait IntoCApiValue {
 impl IntoCApiValue for Value {
     fn into_cv(self) -> wasm_val_t {
         match self {
-            Value::I32(val) => wasm_val_t {
+            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 },
             },
-            Value::I64(val) => wasm_val_t {
+            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 },
             },
-            Value::F32(val) => wasm_val_t {
+            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 },
             },
-            Value::F64(val) => wasm_val_t {
+            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 },
             },
-            Value::FuncRef(Some(val)) => wasm_val_t {
+            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) },
                 },
             },
-            Value::FuncRef(None) => wasm_val_t {
+            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()) },
                 },
             },
-            Value::ExternRef(_) => panic!(
+            Self::ExternRef(_) => panic!(
                 "Creating host values from guest ExternRefs is not currently supported in wamr ."
             ),
-            Value::ExceptionRef(_) => {
+            Self::ExceptionRef(_) => {
                 panic!("Creating host values from guest V128s is not currently supported in wamr.")
             }
-            Value::V128(_) => {
+            Self::V128(_) => {
                 panic!("Creating host values from guest V128s is not currently supported in wamr.")
             }
         }
@@ -119,14 +119,14 @@ pub trait IntoCApiType {
 impl IntoCApiType for Type {
     fn into_ct(self) -> wasm_valkind_t {
         match self as _ {
-            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
-            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
-            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
-            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
-            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
-            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
-            Type::V128 => bindings::wasm_valkind_enum_WASM_V128 as _,
-            Type::ExceptionRef => panic!("v8 currently does not support exnrefs"),
+            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"),
         }
     }
 }
diff --git a/lib/api/src/backend/wamr/vm/mod.rs b/lib/api/src/backend/wamr/vm/mod.rs
index 01e04abdd4..87ccd91e9a 100644
--- a/lib/api/src/backend/wamr/vm/mod.rs
+++ b/lib/api/src/backend/wamr/vm/mod.rs
@@ -11,6 +11,7 @@ use super::{
     table::Table,
 };
 use crate::{AsStoreMut, BackendFunction, BackendGlobal, BackendMemory, BackendTable, Extern};
+use std::ptr::NonNull;
 use wasmer_types::RawValue;
 
 pub use super::error::Trap;
@@ -45,11 +46,14 @@ pub(crate) type VMConfig = ();
 
 impl crate::VMExternToExtern for VMExtern {
     fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
-        let kind = unsafe { wasm_extern_kind(&mut *self) };
+        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(&mut *self) };
+                let func = unsafe { wasm_extern_as_func(raw) };
                 if func.is_null() {
                     panic!("The wasm-c-api reported extern as function, but is not");
                 }
@@ -59,7 +63,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             1 => {
-                let global = unsafe { wasm_extern_as_global(&mut *self) };
+                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");
                 }
@@ -69,7 +73,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             2 => {
-                let table = unsafe { wasm_extern_as_table(&mut *self) };
+                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");
                 }
@@ -79,7 +83,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             3 => {
-                let memory = unsafe { wasm_extern_as_memory(&mut *self) };
+                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");
                 }
diff --git a/lib/api/src/backend/wasmi/entities/engine.rs b/lib/api/src/backend/wasmi/entities/engine.rs
index 896d40fce3..a3e9054769 100644
--- a/lib/api/src/backend/wasmi/entities/engine.rs
+++ b/lib/api/src/backend/wasmi/entities/engine.rs
@@ -1,10 +1,10 @@
 //! Data types, functions and traits for `wasmi` runtime's `Engine` implementation.
 use crate::{
-    backend::wasmi::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
     BackendEngine,
+    backend::wasmi::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
 };
 use std::sync::Arc;
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 #[derive(Debug)]
 pub(crate) struct CApiEngine {
@@ -86,8 +86,8 @@ impl crate::Engine {
 
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::engine::Engine`].
     pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::engine::Engine {
-        match self.be {
-            BackendEngine::Wasmi(ref mut s) => s,
+        match &mut self.be {
+            BackendEngine::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` engine!"),
         }
     }
@@ -100,9 +100,9 @@ impl crate::Engine {
 
 impl From<Engine> for crate::Engine {
     fn from(value: Engine) -> Self {
-        crate::Engine {
+        Self {
             be: BackendEngine::Wasmi(value),
-            id: crate::Engine::atomic_next_engine_id(),
+            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
index 4ae913cfa0..1de3579564 100644
--- a/lib/api/src/backend/wasmi/entities/exception.rs
+++ b/lib/api/src/backend/wasmi/entities/exception.rs
@@ -4,8 +4,8 @@ use std::any::Any;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    wasmi::vm::{VMException, VMExceptionRef},
     AsStoreMut, AsStoreRef, Tag, Value,
+    wasmi::vm::{VMException, VMExceptionRef},
 };
 
 use super::store::StoreHandle;
@@ -22,42 +22,6 @@ unsafe impl Sync for Exception {}
 impl Exception {
     /// Create a new [`Exception`].
     pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
-        todo!()
-    }
-}
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-/// A WebAssembly `extern ref` in `wasmi`.
-pub(crate) struct ExceptionRef;
-
-impl ExceptionRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in wasmi");
-    }
-
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        unimplemented!("ExceptionRef is not yet supported in wasmi");
-    }
-
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        unimplemented!("ExceptionRef is not yet supported in wasmi");
-    }
-
-    pub(crate) unsafe fn from_vm_exceptionref(
-        _store: &mut impl AsStoreMut,
-        _vm_exceptionref: VMExceptionRef,
-    ) -> Self {
-        unimplemented!("ExceptionRef is not yet supported in wasmi");
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+        unimplemented!("Exception handling is not yet supported in wasmi");
     }
 }
diff --git a/lib/api/src/backend/wasmi/entities/function/env.rs b/lib/api/src/backend/wasmi/entities/function/env.rs
index c5062e897e..04e691d96d 100644
--- a/lib/api/src/backend/wasmi/entities/function/env.rs
+++ b/lib/api/src/backend/wasmi/entities/function/env.rs
@@ -1,9 +1,9 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
 use crate::{
+    StoreMut,
     store::{AsStoreMut, AsStoreRef, StoreRef},
     wasmi::{store::StoreHandle, vm::VMFunctionEnvironment},
-    StoreMut,
 };
 
 #[derive(Debug)]
@@ -62,7 +62,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// Convert it into a `FunctionEnvMut`
-    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    pub fn into_mut<'a>(self, store: &'a mut impl AsStoreMut) -> FunctionEnvMut<'a, T>
     where
         T: Any + Send + 'static + Sized,
     {
@@ -137,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<'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
@@ -185,16 +185,16 @@ impl<T> crate::FunctionEnv<T> {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::function::env::FunctionEnv`].
     pub fn as_wasmi(&self) -> &FunctionEnv<T> {
-        match self.0 {
-            crate::BackendFunctionEnv::Wasmi(ref s) => s,
+        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 self.0 {
-            crate::BackendFunctionEnv::Wasmi(ref mut s) => s,
+        match &mut self.0 {
+            crate::BackendFunctionEnv::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` function env!"),
         }
     }
@@ -202,12 +202,12 @@ impl<T> crate::FunctionEnv<T> {
 
 impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
     fn from(value: FunctionEnvMut<'a, T>) -> Self {
-        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Wasmi(value))
+        Self(crate::BackendFunctionEnvMut::Wasmi(value))
     }
 }
 
 impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
     fn from(value: FunctionEnv<T>) -> Self {
-        crate::FunctionEnv(crate::BackendFunctionEnv::Wasmi(value))
+        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
index fef411bce7..7526fd56b2 100644
--- a/lib/api/src/backend/wasmi/entities/function/mod.rs
+++ b/lib/api/src/backend/wasmi/entities/function/mod.rs
@@ -7,15 +7,15 @@ use std::{
 };
 
 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},
     },
-    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
-    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
-    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
 };
 
 use super::{super::error::Trap, store::StoreHandle};
@@ -90,9 +90,9 @@ impl Function {
         let params = fn_ty.params();
 
         let mut param_types = params
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -105,9 +105,9 @@ impl Function {
 
         let results = fn_ty.results();
         let mut result_types = results
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -151,7 +151,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -164,9 +164,9 @@ impl Function {
         Rets: WasmTypeList,
     {
         let mut param_types = Args::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -178,9 +178,9 @@ impl Function {
         };
 
         let mut result_types = Rets::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -225,7 +225,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -242,9 +242,9 @@ impl Function {
         T: Send + 'static,
     {
         let mut param_types = Args::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -256,9 +256,9 @@ impl Function {
         };
 
         let mut result_types = Rets::wasm_types()
-            .into_iter()
+            .iter()
             .map(|param| {
-                let kind = param.into_ct();
+                let kind = (*param).into_ct();
                 unsafe { wasm_valtype_new(kind) }
             })
             .collect::<Vec<_>>();
@@ -307,7 +307,7 @@ impl Function {
             panic!("failed when creating new typed function");
         }
 
-        Function {
+        Self {
             handle: wasm_function,
         }
     }
@@ -359,7 +359,7 @@ impl Function {
         let mut args = {
             unsafe {
                 let mut wasm_params = params
-                    .into_iter()
+                    .iter()
                     .map(|v| IntoCApiValue::into_cv(v.clone()))
                     .collect::<Vec<_>>()
                     .into_boxed_slice();
@@ -394,7 +394,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)),
                 }
@@ -406,14 +406,15 @@ impl Function {
             return Err(Into::<Trap>::into(trap).into());
         }
 
-        unsafe {
+        let values = unsafe {
             let results = std::ptr::slice_from_raw_parts(results.data, results.size);
-            return Ok((*results)
-                .into_iter()
+            (*results)
+                .iter()
                 .map(|v| IntoWasmerValue::into_wv(*v))
                 .collect::<Vec<_>>()
-                .into_boxed_slice());
-        }
+                .into_boxed_slice()
+        };
+        Ok(values)
     }
 
     pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
@@ -459,15 +460,18 @@ where
     {
         let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
 
-        let mut store = (*r).store.as_store_mut();
-        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut 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 = &(*r).func;
+        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).size {
-            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        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 {
@@ -481,13 +485,18 @@ where
                     .map(IntoCApiValue::into_cv)
                     .collect();
 
-                if c_results.len() != (*rets).size {
-                    panic!("when calling host function: number of observed results differ from wanted results")
+                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 {
-                    for i in 0..(*rets).size {
-                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    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;
                     }
                 }
 
@@ -505,7 +514,7 @@ where
         }
     }
 
-    return fn_callback::<F, T>;
+    fn_callback::<F, T>
 }
 
 impl std::fmt::Debug for Function {
@@ -525,16 +534,16 @@ impl crate::Function {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::function::Function`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::function::Function {
-        match self.0 {
-            BackendFunction::Wasmi(ref s) => s,
+        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 self.0 {
-            BackendFunction::Wasmi(ref mut s) => s,
+        match &mut self.0 {
+            BackendFunction::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` function!"),
         }
     }
@@ -558,43 +567,49 @@ macro_rules! impl_host_function {
                 RetsAsResult: IntoResult<Rets>,
                 Func: Fn($( $x , )*) -> RetsAsResult + 'static,
             {
-                let mut r: *mut crate::backend::wasmi::function::FunctionCallbackEnv<Func> = unsafe {std::mem::transmute(env)};
-                let store = &mut (*r).store.as_store_mut();
+                let mut 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 = (*(*args).data.wrapping_add(i)).clone();
+                    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 $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+                    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 {
-                    ((*r).func)( $( $x, )* ).into_result()
+                    (func)( $( $x, )* ).into_result()
                 }));
 
                 match result {
                     Ok(Ok(result)) => {
 
                         let types = Rets::wasm_types();
-                        let mut native_results = result.into_array(store);
+                        let mut native_results = unsafe { 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()))
+                        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();
-
-                        if c_results.len() != (*results).size {
+                        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 {
-                            for i in 0..(*results).size {
-                                *((*results).data.wrapping_add(i)) = c_results[i]
+                            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;
                             }
                         }
 
@@ -630,47 +645,51 @@ macro_rules! impl_host_function {
             {
 
               let r: *mut (crate::backend::wasmi::function::FunctionCallbackEnv<'_, Func>) = env as _;
-              let store = &mut (*r).store.as_store_mut();
+              let store = unsafe { &mut (*r).store.as_store_mut() };
 
               let mut i = 0;
+              let args_ptr = unsafe { (*args).data };
 
               $(
-              let c_arg = (*(*args).data.wrapping_add(i)).clone();
+              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 $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+              let native_value = unsafe { $x::Native::from_raw(store, raw_arg) };
+              let $x : $x = FromToNativeWasmType::from_native(native_value);
 
               i += 1;
               )*
 
-              let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+              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 = &(*r).func;
+              let func: &Func = unsafe { &(*r).func };
 
               let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
-                  ((*r).func)(BackendFunctionEnvMut::Wasmi(fn_env).into(), $( $x, )* ).into_result()
+                  (func)(BackendFunctionEnvMut::Wasmi(fn_env).into(), $( $x, )* ).into_result()
               }));
 
 
               match result {
                   Ok(Ok(result)) => {
                     let types = Rets::wasm_types();
-                    let mut native_results = result.into_array(store);
+                    let mut native_results = unsafe { 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 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();
-
-                    if c_results.len() != (*results).size {
+                    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 {
-                        for i in 0..(*results).size {
-                            *((*results).data.wrapping_add(i)) = c_results[i]
+                        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() }
diff --git a/lib/api/src/backend/wasmi/entities/function/typed.rs b/lib/api/src/backend/wasmi/entities/function/typed.rs
index d4f4806768..63972edfd9 100644
--- a/lib/api/src/backend/wasmi/entities/function/typed.rs
+++ b/lib/api/src/backend/wasmi/entities/function/typed.rs
@@ -11,9 +11,9 @@
 use std::iter::FromIterator;
 
 use crate::{
-    backend::wasmi::{bindings::*, error::Trap, function::Function, utils::convert::*},
     AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
     TypedFunction, Value, WasmTypeList,
+    backend::wasmi::{bindings::*, error::Trap, function::Function, utils::convert::*},
 };
 use wasmer_types::RawValue;
 
@@ -131,9 +131,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/wasmi/entities/global.rs b/lib/api/src/backend/wasmi/entities/global.rs
index 3304083423..393bb61e78 100644
--- a/lib/api/src/backend/wasmi/entities/global.rs
+++ b/lib/api/src/backend/wasmi/entities/global.rs
@@ -2,6 +2,7 @@
 use wasmer_types::{GlobalType, Mutability};
 
 use crate::{
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
     vm::{VMExtern, VMExternGlobal},
     wasmi::{
         bindings::{
@@ -12,7 +13,6 @@ use crate::{
         utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
         vm::VMGlobal,
     },
-    AsStoreMut, AsStoreRef, RuntimeError, Value,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/wasmi/entities/instance.rs b/lib/api/src/backend/wasmi/entities/instance.rs
index 5b3bcc14e2..72765dc3e5 100644
--- a/lib/api/src/backend/wasmi/entities/instance.rs
+++ b/lib/api/src/backend/wasmi/entities/instance.rs
@@ -2,9 +2,9 @@
 use std::sync::Arc;
 
 use crate::{
+    AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError, Module,
     backend::wasmi::bindings::*, entities::external::VMExternToExtern, vm::VMExtern,
-    wasmi::error::Trap, AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError,
-    Module,
+    wasmi::error::Trap,
 };
 
 #[derive(PartialEq, Eq)]
@@ -14,6 +14,7 @@ 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,
@@ -48,7 +49,7 @@ impl InstanceHandle {
             return Err(InstantiationError::Start(trap.into()));
         }
 
-        Ok(InstanceHandle(instance))
+        Ok(Self(instance))
     }
 
     fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
@@ -77,7 +78,7 @@ impl InstanceHandle {
 
         let c_api_exports: Exports = c_api_exports
             .into_iter()
-            .zip(c_api_externs.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);
@@ -110,6 +111,7 @@ pub struct Instance {
 }
 
 impl Instance {
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new(
         store: &mut impl AsStoreMut,
         module: &Module,
@@ -124,9 +126,10 @@ impl Instance {
             })
             .collect::<Vec<_>>();
 
-        return Self::new_by_index(store, module, &externs);
+        Self::new_by_index(store, module, &externs)
     }
 
+    #[allow(clippy::result_large_err)]
     pub(crate) fn new_by_index(
         store: &mut impl AsStoreMut,
         module: &Module,
diff --git a/lib/api/src/backend/wasmi/entities/memory/mod.rs b/lib/api/src/backend/wasmi/entities/memory/mod.rs
index f7c0c64b60..db0858db64 100644
--- a/lib/api/src/backend/wasmi/entities/memory/mod.rs
+++ b/lib/api/src/backend/wasmi/entities/memory/mod.rs
@@ -7,10 +7,10 @@ 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},
-    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
 };
 
 pub(crate) mod view;
@@ -167,7 +167,7 @@ impl Memory {
     /// Cloning memory will create another reference to the same memory that
     /// can be put into a new store
     pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        Ok(self.handle.clone())
+        Ok(self.handle)
     }
 
     /// Copying the memory will actually copy all the bytes in the memory to
@@ -295,26 +295,28 @@ 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u8>(&mut src, &mut dst, &mut len) };
     }
 }
 
@@ -322,26 +324,28 @@ unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: us
 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(std::mem::size_of::<T>());
-        *dst = dst.add(std::mem::size_of::<T>());
-        *len -= std::mem::size_of::<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 {
-        copy_one::<u64>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u64>(&mut src, &mut dst, &mut len) };
     }
     if len >= 4 {
-        copy_one::<u32>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u32>(&mut src, &mut dst, &mut len) };
     }
     if len >= 2 {
-        copy_one::<u16>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u16>(&mut src, &mut dst, &mut len) };
     }
     if len >= 1 {
-        copy_one::<u8>(&mut src, &mut dst, &mut len);
+        unsafe { copy_one::<u8>(&mut src, &mut dst, &mut len) };
     }
 }
 
@@ -356,16 +360,16 @@ impl crate::Memory {
 
     /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::memory::Memory`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::memory::Memory {
-        match self.0 {
-            BackendMemory::Wasmi(ref s) => s,
+        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 self.0 {
-            BackendMemory::Wasmi(ref mut s) => s,
+        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
index 51adca872b..90b17d6800 100644
--- a/lib/api/src/backend/wasmi/entities/memory/view.rs
+++ b/lib/api/src/backend/wasmi/entities/memory/view.rs
@@ -4,9 +4,9 @@ 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,
-    AsStoreRef, MemoryAccessError,
 };
 
 /// A WebAssembly `memory` view.
@@ -25,7 +25,7 @@ impl<'a> MemoryView<'a> {
     pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let c_memory: *mut wasm_memory_t = memory.handle;
 
-        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let 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 _) };
 
@@ -62,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.data_unchecked_mut()
+        unsafe { std::slice::from_raw_parts(self.buffer.base as *const u8, self.buffer.len) }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -77,7 +77,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+        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/wasmi/entities/module.rs b/lib/api/src/backend/wasmi/entities/module.rs
index ad0aa9d39d..a0b5d98241 100644
--- a/lib/api/src/backend/wasmi/entities/module.rs
+++ b/lib/api/src/backend/wasmi/entities/module.rs
@@ -2,10 +2,10 @@
 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,
     },
-    AsEngineRef, BackendModule, IntoBytes,
 };
 
 use bytes::Bytes;
@@ -42,10 +42,10 @@ impl ModuleHandle {
         let store = std::sync::Mutex::new(store);
 
         if inner.is_null() {
-            return Err(CompileError::Validate(format!("module is null")));
+            return Err(CompileError::Validate("module is null".to_string()));
         }
 
-        Ok(ModuleHandle { inner, store })
+        Ok(Self { inner, store })
     }
 }
 impl Drop for ModuleHandle {
@@ -74,6 +74,7 @@ impl Module {
         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],
@@ -103,24 +104,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(
@@ -128,7 +128,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(
@@ -136,7 +136,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 {
@@ -175,16 +175,16 @@ impl crate::Module {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::module::Module`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::module::Module {
-        match self.0 {
-            BackendModule::Wasmi(ref s) => s,
+        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 self.0 {
-            BackendModule::Wasmi(ref mut s) => s,
+        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
index f971d270e6..d27503ae74 100644
--- a/lib/api/src/backend/wasmi/entities/store/mod.rs
+++ b/lib/api/src/backend/wasmi/entities/store/mod.rs
@@ -1,8 +1,8 @@
 //! 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},
-    AsStoreRef, BackendStore, StoreRef,
 };
 
 mod obj;
@@ -25,7 +25,7 @@ impl std::fmt::Debug for Store {
 impl Store {
     pub(crate) fn new(engine: crate::engine::Engine) -> Self {
         let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_wasmi().inner.engine) };
-        Store { inner, engine }
+        Self { inner, engine }
     }
 
     pub(crate) fn engine(&self) -> &Engine {
diff --git a/lib/api/src/backend/wasmi/entities/store/obj.rs b/lib/api/src/backend/wasmi/entities/store/obj.rs
index e22eb78b18..3ee18e5bfe 100644
--- a/lib/api/src/backend/wasmi/entities/store/obj.rs
+++ b/lib/api/src/backend/wasmi/entities/store/obj.rs
@@ -1,8 +1,8 @@
 use std::{fmt, marker::PhantomData, num::NonZeroUsize};
 
 use crate::{
-    backend::wasmi::vm::{VMFunctionEnvironment, VMGlobal},
     AsStoreMut,
+    backend::wasmi::vm::{VMFunctionEnvironment, VMGlobal},
 };
 
 pub use wasmer_types::StoreId;
@@ -11,7 +11,7 @@ impl crate::StoreObjects {
     /// Consume [`self`] into [`crate::backend::wasmi::store::StoreObjects`].
     pub fn into_wasmi(self) -> crate::backend::wasmi::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wasmi(s) => s,
+            Self::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` store!"),
         }
     }
@@ -19,7 +19,7 @@ impl crate::StoreObjects {
     /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::store::StoreObjects`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wasmi(s) => s,
+            Self::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` store!"),
         }
     }
@@ -27,7 +27,7 @@ impl crate::StoreObjects {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::store::StoreObjects`].
     pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::store::StoreObjects {
         match self {
-            crate::StoreObjects::Wasmi(s) => s,
+            Self::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` store!"),
         }
     }
@@ -107,7 +107,7 @@ impl StoreObjects {
     }
 
     /// Return an immutable iterator over all globals
-    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+    pub fn iter_globals<'a>(&'a self) -> core::slice::Iter<'a, VMGlobal> {
         self.globals.iter()
     }
 
diff --git a/lib/api/src/backend/wasmi/entities/table.rs b/lib/api/src/backend/wasmi/entities/table.rs
index 52bc54f695..cb8f3b354d 100644
--- a/lib/api/src/backend/wasmi/entities/table.rs
+++ b/lib/api/src/backend/wasmi/entities/table.rs
@@ -2,13 +2,13 @@
 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,
     },
-    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -26,10 +26,7 @@ impl Table {
 
         let limits = Box::into_raw(Box::new(wasm_limits_t {
             min: ty.minimum,
-            max: match ty.maximum {
-                Some(v) => v,
-                None => 0,
-            },
+            max: ty.maximum.unwrap_or_default(),
         }));
 
         unsafe { wasm_tabletype_new(valtype, limits) }
@@ -115,7 +112,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {val:?} "
-                    )))
+                    )));
                 }
             };
 
@@ -147,7 +144,7 @@ impl Table {
                 _ => {
                     return Err(RuntimeError::new(format!(
                         "Could not grow table due to unsupported init value type: {init:?} "
-                    )))
+                    )));
                 }
             };
             if !wasm_table_grow(self.handle, delta, init) {
@@ -191,16 +188,16 @@ impl crate::Table {
 
     /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::table::Table`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::table::Table {
-        match self.0 {
-            BackendTable::Wasmi(ref s) => s,
+        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 self.0 {
-            BackendTable::Wasmi(ref mut s) => s,
+        match &mut self.0 {
+            BackendTable::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` table!"),
         }
     }
@@ -218,7 +215,7 @@ impl crate::BackendTable {
     /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::table::Table`].
     pub fn as_wasmi(&self) -> &crate::backend::wasmi::table::Table {
         match self {
-            Self::Wasmi(ref s) => s,
+            Self::Wasmi(s) => s,
             _ => panic!("Not a `wasmi` table!"),
         }
     }
@@ -226,7 +223,7 @@ impl crate::BackendTable {
     /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::table::Table`].
     pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::table::Table {
         match self {
-            Self::Wasmi(ref mut s) => s,
+            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
index 901c9ac4bb..277d0322ca 100644
--- a/lib/api/src/backend/wasmi/entities/tag.rs
+++ b/lib/api/src/backend/wasmi/entities/tag.rs
@@ -2,9 +2,9 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef,
     vm::{VMExtern, VMExternTag},
     wasmi::vm::VMTag,
-    AsStoreMut, AsStoreRef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/lib/api/src/backend/wasmi/error.rs b/lib/api/src/backend/wasmi/error.rs
index 4c96960419..02f22e61ef 100644
--- a/lib/api/src/backend/wasmi/error.rs
+++ b/lib/api/src/backend/wasmi/error.rs
@@ -1,9 +1,12 @@
 use std::{
     error::Error,
-    ffi::{c_char, CStr},
+    ffi::{CStr, c_char},
 };
 
-use crate::{wasmi::bindings::*, AsStoreMut};
+use crate::{
+    AsStoreMut,
+    wasmi::{bindings::*, vm::VMExceptionRef},
+};
 
 #[derive(Debug)]
 enum InnerTrap {
@@ -52,19 +55,31 @@ impl Trap {
         }
     }
 
+    /// 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 = std::mem::zeroed();
+                let mut data = unsafe { std::mem::zeroed() };
                 // let x = format!("")
-                let s1 = format!("🐛{:p}", err_ptr);
+                let s1 = format!("🐛{err_ptr:p}");
                 let _s = s1.into_bytes().into_boxed_slice();
-                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                unsafe {
+                    wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                }
                 std::mem::forget(_s);
                 let store = store.as_store_mut();
-                wasm_trap_new(store.inner.store.as_wasmi().inner, &mut data)
+                unsafe { wasm_trap_new(store.inner.store.as_wasmi().inner, &data) }
             }
         }
     }
@@ -89,16 +104,12 @@ impl From<*mut wasm_trap_t> for Trap {
                 .unwrap()
         };
 
-        println!("{message}");
-
         if message.starts_with("Exception: 🐛") {
             let ptr_str = message.replace("Exception: 🐛", "");
             let ptr: Box<dyn Error + Send + Sync + 'static> = unsafe {
                 let r = ptr_str.trim_start_matches("0x");
-                std::ptr::read(
-                    (usize::from_str_radix(&r, 16).unwrap()
-                        as *const Box<dyn Error + Send + Sync + 'static>),
-                )
+                std::ptr::read(usize::from_str_radix(r, 16).unwrap()
+                    as *const Box<dyn Error + Send + Sync + 'static>)
             };
 
             Self {
@@ -124,7 +135,7 @@ impl std::error::Error for Trap {
 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::User(e) => write!(f, "{e}"),
             InnerTrap::CApi(value) => {
                 // let message: wasm_message_t;
                 // wasm_trap_message(value, &mut message);
@@ -144,7 +155,7 @@ impl std::fmt::Display for Trap {
 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::User(e) => write!(f, "{e}"),
             InnerTrap::CApi(value) => {
                 // let message: wasm_message_t;
                 // wasm_trap_message(value, &mut message);
@@ -167,6 +178,6 @@ impl From<Trap> for crate::RuntimeError {
             return trap.downcast::<Self>().unwrap();
         }
 
-        crate::RuntimeError::new_from_source(crate::BackendTrap::Wasmi(trap), vec![], None)
+        Self::new_from_source(crate::BackendTrap::Wasmi(trap), vec![], None)
     }
 }
diff --git a/lib/api/src/backend/wasmi/utils/convert.rs b/lib/api/src/backend/wasmi/utils/convert.rs
index 9c2746821e..a1d45fcddb 100644
--- a/lib/api/src/backend/wasmi/utils/convert.rs
+++ b/lib/api/src/backend/wasmi/utils/convert.rs
@@ -1,5 +1,6 @@
 /// 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,
@@ -7,7 +8,6 @@ use crate::{
         },
         function,
     },
-    BackendFunction, Function, Value,
 };
 use wasmer_types::Type;
 
@@ -19,37 +19,43 @@ pub trait IntoCApiValue {
 impl IntoCApiValue for Value {
     fn into_cv(self) -> wasm_val_t {
         match self {
-            Value::I32(val) => wasm_val_t {
+            Self::I32(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_I32 as _,
                 of: wasm_val_t__bindgen_ty_1 { i32_: val },
             },
-            Value::I64(val) => wasm_val_t {
+            Self::I64(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_I64 as _,
                 of: wasm_val_t__bindgen_ty_1 { i64_: val },
             },
-            Value::F32(val) => wasm_val_t {
+            Self::F32(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_F32 as _,
                 of: wasm_val_t__bindgen_ty_1 { f32_: val },
             },
-            Value::F64(val) => wasm_val_t {
+            Self::F64(val) => wasm_val_t {
                 kind: bindings::wasm_valkind_enum_WASM_F64 as _,
                 of: wasm_val_t__bindgen_ty_1 { f64_: val },
             },
-            Value::FuncRef(Some(val)) => wasm_val_t {
+            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) },
                 },
             },
-            Value::FuncRef(None) => wasm_val_t {
+            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()) },
                 },
             },
-            Value::ExternRef(_) => panic!("Creating host values from guest ExternRefs is not currently supported in wasmi.") ,
-            Value::ExceptionRef(_) => panic!("Creating host values from guest ExceptionRefs is not currently supported in wasmi.") ,
-            Value::V128(_) => panic!("Creating host values from guest V128s is not currently supported in wasmi."),
+            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.")
+            }
         }
     }
 }
@@ -109,14 +115,14 @@ pub trait IntoCApiType {
 impl IntoCApiType for Type {
     fn into_ct(self) -> wasm_valkind_t {
         match self as _ {
-            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
-            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
-            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
-            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
-            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
-            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
-            Type::V128 => panic!("wasmi does not support V128!"),
-            Type::ExceptionRef => panic!("wasmi does not support exnrefs!"),
+            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!"),
         }
     }
 }
diff --git a/lib/api/src/backend/wasmi/vm/mod.rs b/lib/api/src/backend/wasmi/vm/mod.rs
index 43f490b86c..055785fb8f 100644
--- a/lib/api/src/backend/wasmi/vm/mod.rs
+++ b/lib/api/src/backend/wasmi/vm/mod.rs
@@ -44,12 +44,13 @@ 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(&mut *self) };
+        let kind = unsafe { wasm_extern_kind(self) };
 
         match kind as u32 {
             0 => {
-                let func = unsafe { wasm_extern_as_func(&mut *self) };
+                let func = unsafe { wasm_extern_as_func(self) };
                 if func.is_null() {
                     panic!("The wasm-c-api reported extern as function, but is not");
                 }
@@ -59,7 +60,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             1 => {
-                let global = unsafe { wasm_extern_as_global(&mut *self) };
+                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");
                 }
@@ -69,7 +70,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             2 => {
-                let table = unsafe { wasm_extern_as_table(&mut *self) };
+                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");
                 }
@@ -79,7 +80,7 @@ impl crate::VMExternToExtern for VMExtern {
                 ))
             }
             3 => {
-                let memory = unsafe { wasm_extern_as_memory(&mut *self) };
+                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");
                 }
@@ -127,7 +128,7 @@ impl VMFuncRef {
     }
 }
 
-pub(crate) struct VMExceptionRef(*mut wasm_ref_t);
+pub struct VMExceptionRef(*mut wasm_ref_t);
 impl VMExceptionRef {
     /// Converts the `VMExceptionRef` into a `RawValue`.
     pub fn into_raw(self) -> RawValue {
diff --git a/lib/api/src/entities/engine/engine_ref.rs b/lib/api/src/entities/engine/engine_ref.rs
index d33eb04860..8edaa93d54 100644
--- a/lib/api/src/entities/engine/engine_ref.rs
+++ b/lib/api/src/entities/engine/engine_ref.rs
@@ -61,7 +61,7 @@ where
 
 impl AsEngineRef for Engine {
     #[inline]
-    fn as_engine_ref(&self) -> EngineRef {
+    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
index 8c0326e1d6..f37af54f34 100644
--- a/lib/api/src/entities/engine/inner.rs
+++ b/lib/api/src/entities/engine/inner.rs
@@ -1,6 +1,6 @@
 use bytes::Bytes;
 use std::{path::Path, sync::Arc};
-use wasmer_types::{target::Target, DeserializeError, Features};
+use wasmer_types::{DeserializeError, Features, target::Target};
 
 #[cfg(feature = "sys")]
 use wasmer_compiler::Artifact;
@@ -8,8 +8,8 @@ use wasmer_compiler::Artifact;
 use wasmer_compiler::CompilerConfig;
 
 use crate::{
-    macros::backend::{gen_rt_ty, match_rt},
     BackendKind, IntoBytes, Store,
+    macros::backend::{gen_rt_ty, match_rt},
 };
 
 gen_rt_ty!(Engine @derives Debug, Clone);
@@ -44,7 +44,9 @@ impl BackendEngine {
     ) -> Result<Arc<Artifact>, DeserializeError> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(s) => s.deserialize_unchecked(bytes.into_bytes().to_owned().into()),
+            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(),
             )),
@@ -66,7 +68,7 @@ impl BackendEngine {
     ) -> Result<Arc<Artifact>, DeserializeError> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(s) => s.deserialize(bytes.into_bytes().to_owned().into()),
+            Self::Sys(s) => unsafe { s.deserialize(bytes.into_bytes().to_owned().into()) },
             _ => Err(DeserializeError::Generic(
                 "The selected runtime does not support `deserialize`".into(),
             )),
@@ -93,7 +95,7 @@ impl BackendEngine {
     ) -> Result<Arc<Artifact>, DeserializeError> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(s) => s.deserialize_from_file_unchecked(file_ref),
+            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(),
             )),
@@ -117,7 +119,7 @@ impl BackendEngine {
     ) -> Result<Arc<Artifact>, DeserializeError> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(s) => s.deserialize_from_file(file_ref),
+            Self::Sys(s) => unsafe { s.deserialize_from_file(file_ref) },
             _ => Err(DeserializeError::Generic(
                 "The selected runtime does not support `deserialize_from_file`".into(),
             )),
diff --git a/lib/api/src/entities/engine/mod.rs b/lib/api/src/entities/engine/mod.rs
index b28b250918..1537507a9d 100644
--- a/lib/api/src/entities/engine/mod.rs
+++ b/lib/api/src/entities/engine/mod.rs
@@ -3,8 +3,8 @@
 use bytes::Bytes;
 use std::{path::Path, sync::Arc};
 use wasmer_types::{
-    target::{Target, UserCompilerOptimizations},
     CompileError, DeserializeError, Features,
+    target::{Target, UserCompilerOptimizations},
 };
 
 #[cfg(feature = "sys")]
@@ -186,7 +186,7 @@ impl Engine {
         &self,
         bytes: impl IntoBytes,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        self.be.deserialize_unchecked(bytes)
+        unsafe { self.be.deserialize_unchecked(bytes) }
     }
 
     #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
@@ -198,7 +198,7 @@ impl Engine {
     /// Currently, only the `sys` engines support it, and only when the target
     /// architecture is not `wasm32`.
     unsafe fn deserialize(&self, bytes: impl IntoBytes) -> Result<Arc<Artifact>, DeserializeError> {
-        self.be.deserialize(bytes)
+        unsafe { self.be.deserialize(bytes) }
     }
 
     #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
@@ -218,7 +218,7 @@ impl Engine {
         &self,
         file_ref: &Path,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        self.be.deserialize_from_file_unchecked(file_ref)
+        unsafe { self.be.deserialize_from_file_unchecked(file_ref) }
     }
 
     #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
@@ -235,7 +235,7 @@ impl Engine {
         &self,
         file_ref: &Path,
     ) -> Result<Arc<Artifact>, DeserializeError> {
-        self.be.deserialize_from_file_unchecked(file_ref)
+        unsafe { self.be.deserialize_from_file_unchecked(file_ref) }
     }
 
     /// Add suggested optimizations to this engine.
diff --git a/lib/api/src/entities/exception/exnref/inner.rs b/lib/api/src/entities/exception/exnref/inner.rs
deleted file mode 100644
index 9940a78a2f..0000000000
--- a/lib/api/src/entities/exception/exnref/inner.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-use std::any::Any;
-
-use crate::entities::store::{AsStoreMut, AsStoreRef};
-use crate::macros::backend::{gen_rt_ty, match_rt};
-use crate::vm::VMExceptionRef;
-use crate::StoreRef;
-
-gen_rt_ty!(ExceptionRef @derives derive_more::From, Debug, Clone ; @path exception);
-
-impl BackendExceptionRef {
-    /// Make a new extern reference
-    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        match &store.as_store_mut().inner.store {
-            #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(s) => Self::Sys(
-                crate::backend::sys::entities::exception::ExceptionRef::new(store, value),
-            ),
-            #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(s) => Self::Wamr(
-                crate::backend::wamr::entities::exception::ExceptionRef::new(store, value),
-            ),
-            #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(s) => Self::Wasmi(
-                crate::backend::wasmi::entities::exception::ExceptionRef::new(store, value),
-            ),
-            #[cfg(feature = "v8")]
-            crate::BackendStore::V8(s) => Self::V8(
-                crate::backend::v8::entities::exception::ExceptionRef::new(store, value),
-            ),
-            #[cfg(feature = "js")]
-            crate::BackendStore::Js(s) => Self::Js(
-                crate::backend::js::entities::exception::ExceptionRef::new(store, value),
-            ),
-            #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(s) => Self::Jsc(
-                crate::backend::jsc::entities::exception::ExceptionRef::new(store, value),
-            ),
-        }
-    }
-
-    /// Try to downcast to the given value.
-    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        match_rt!(on self => r {
-            r.downcast::<T>(store)
-        })
-    }
-
-    /// Create a [`VMExceptionRef`] from [`Self`].
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        match self {
-            #[cfg(feature = "sys")]
-            Self::Sys(r) => VMExceptionRef::Sys(r.vm_exceptionref()),
-            #[cfg(feature = "wamr")]
-            Self::Wamr(r) => VMExceptionRef::Wamr(r.vm_exceptionref()),
-            #[cfg(feature = "wasmi")]
-            Self::Wasmi(r) => VMExceptionRef::Wasmi(r.vm_exceptionref()),
-            #[cfg(feature = "v8")]
-            Self::V8(r) => VMExceptionRef::V8(r.vm_exceptionref()),
-            #[cfg(feature = "js")]
-            Self::Js(r) => VMExceptionRef::Js(r.vm_exceptionref()),
-            #[cfg(feature = "jsc")]
-            Self::Jsc(r) => VMExceptionRef::Jsc(r.vm_exceptionref()),
-        }
-    }
-
-    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
-    pub(crate) unsafe fn from_vm_exceptionref(
-        store: &mut impl AsStoreMut,
-        vm_externref: VMExceptionRef,
-    ) -> Self {
-        match &store.as_store_mut().inner.store {
-            #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => Self::Sys(
-                crate::backend::sys::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_sys(),
-                ),
-            ),
-            #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => Self::Wamr(
-                crate::backend::wamr::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_wamr(),
-                ),
-            ),
-            #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => Self::Wasmi(
-                crate::backend::wasmi::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_wasmi(),
-                ),
-            ),
-            #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => Self::V8(
-                crate::backend::v8::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_v8(),
-                ),
-            ),
-            #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => Self::Js(
-                crate::backend::js::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_js(),
-                ),
-            ),
-            #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => Self::Jsc(
-                crate::backend::jsc::entities::exception::ExceptionRef::from_vm_exceptionref(
-                    store,
-                    vm_externref.into_jsc(),
-                ),
-            ),
-        }
-    }
-
-    /// Checks whether this `ExceptionRef` can be used with the given context.
-    ///
-    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
-    /// tied to a context and can be freely shared between contexts.
-    ///
-    /// Externref and funcref values are tied to a context and can only be used
-    /// with that context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        match_rt!(on self => r {
-            r.is_from_store(store)
-        })
-    }
-}
diff --git a/lib/api/src/entities/exception/exnref/mod.rs b/lib/api/src/entities/exception/exnref/mod.rs
deleted file mode 100644
index c1f8ca02e6..0000000000
--- a/lib/api/src/entities/exception/exnref/mod.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use std::any::Any;
-
-use crate::entities::store::{AsStoreMut, AsStoreRef};
-use crate::vm::{VMExceptionRef, VMExternRef};
-use crate::StoreRef;
-
-pub(crate) mod inner;
-pub(crate) use inner::*;
-
-#[derive(Debug, Clone, derive_more::From)]
-/// An opaque reference to some data. This reference can be passed through Wasm.
-pub struct ExceptionRef(pub(crate) BackendExceptionRef);
-
-impl ExceptionRef {
-    /// Make a new extern reference
-    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        Self(BackendExceptionRef::new(store, value))
-    }
-
-    /// Try to downcast to the given value.
-    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        self.0.downcast(store)
-    }
-
-    /// Create a [`VMExceptionRef`] from [`Self`].
-    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
-        self.0.vm_exceptionref()
-    }
-
-    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
-    pub(crate) unsafe fn from_vm_exceptionref(
-        store: &mut impl AsStoreMut,
-        vm_externref: VMExceptionRef,
-    ) -> Self {
-        Self(BackendExceptionRef::from_vm_exceptionref(
-            store,
-            vm_externref,
-        ))
-    }
-
-    /// Checks whether this `ExceptionRef` can be used with the given context.
-    ///
-    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
-    /// tied to a context and can be freely shared between contexts.
-    ///
-    /// Externref and funcref values are tied to a context and can only be used
-    /// with that context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.0.is_from_store(store)
-    }
-}
diff --git a/lib/api/src/entities/exception/inner.rs b/lib/api/src/entities/exception/inner.rs
index 3b7c601050..08d0344ca3 100644
--- a/lib/api/src/entities/exception/inner.rs
+++ b/lib/api/src/entities/exception/inner.rs
@@ -1,7 +1,8 @@
+use crate::vm::VMExceptionRef;
 use crate::{
+    AsStoreMut, AsStoreRef, BackendTag, ExportError, Exportable, Extern, Tag, Value,
     macros::backend::{gen_rt_ty, match_rt},
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, Tag, Value,
 };
 
 /// A WebAssembly `global` instance.
@@ -18,38 +19,72 @@ gen_rt_ty!(Exception
 impl BackendException {
     /// Create a new exception with the given tag type and payload.
     #[inline]
-    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+    #[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(_) => Self::Sys(
-                crate::backend::sys::exception::Exception::new(store, tag, payload),
-            ),
-            #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => Self::Wamr(
-                crate::backend::wamr::exception::Exception::new(store, tag, payload),
-            ),
-            #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => Self::Wasmi(
-                crate::backend::wasmi::exception::Exception::new(store, tag, payload),
-            ),
-            #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => Self::V8(crate::backend::v8::exception::Exception::new(
-                store, tag, payload,
-            )),
-            #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => Self::Js(crate::backend::js::exception::Exception::new(
-                store, tag, payload,
-            )),
-            #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => Self::Jsc(
-                crate::backend::jsc::exception::Exception::new(store, tag, payload),
-            ),
+            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 {
-        todo!()
+        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
index 47c562df4e..abdc15acf7 100644
--- a/lib/api/src/entities/exception/mod.rs
+++ b/lib/api/src/entities/exception/mod.rs
@@ -1,13 +1,10 @@
-pub(crate) mod exnref;
-pub use exnref::*;
-
 pub(crate) mod inner;
 pub(crate) use inner::*;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    vm::{VMExtern, VMExternTag},
     AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, Tag, Value,
+    vm::{VMExceptionRef, VMExtern, VMExternTag},
 };
 
 /// A WebAssembly `exception` instance.
@@ -21,13 +18,34 @@ use crate::{
 pub struct Exception(pub(crate) BackendException);
 
 impl Exception {
-    /// Create a new exception with the given tag type and payload.
-    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+    /// 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))
     }
 
-    /// Checks whether this `Exception` comes from the given store.
+    /// 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/entities/exports.rs b/lib/api/src/entities/exports.rs
index 21a5f902d9..5bda72891d 100644
--- a/lib/api/src/entities/exports.rs
+++ b/lib/api/src/entities/exports.rs
@@ -175,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(),
         }
diff --git a/lib/api/src/entities/external/extref/inner.rs b/lib/api/src/entities/external/extref/inner.rs
index 124218aa89..9c974f7cda 100644
--- a/lib/api/src/entities/external/extref/inner.rs
+++ b/lib/api/src/entities/external/extref/inner.rs
@@ -1,9 +1,9 @@
 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;
-use crate::StoreRef;
 
 gen_rt_ty!(ExternRef @derives derive_more::From, Debug, Clone ; @path external);
 
@@ -80,47 +80,47 @@ impl BackendExternRef {
     ) -> Self {
         match &store.as_store_mut().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => Self::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(
+            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(
+            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(
+            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(
+            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(
+            crate::BackendStore::Jsc(_) => Self::Jsc(unsafe {
                 crate::backend::jsc::entities::external::ExternRef::from_vm_externref(
                     store,
                     vm_externref.into_jsc(),
-                ),
-            ),
+                )
+            }),
         }
     }
 
diff --git a/lib/api/src/entities/external/extref/mod.rs b/lib/api/src/entities/external/extref/mod.rs
index 39c60d5d59..6257eb2c10 100644
--- a/lib/api/src/entities/external/extref/mod.rs
+++ b/lib/api/src/entities/external/extref/mod.rs
@@ -1,8 +1,8 @@
 use std::any::Any;
 
+use crate::StoreRef;
 use crate::entities::store::{AsStoreMut, AsStoreRef};
 use crate::vm::VMExternRef;
-use crate::StoreRef;
 
 pub(crate) mod inner;
 pub(crate) use inner::*;
@@ -38,7 +38,7 @@ impl ExternRef {
         store: &mut impl AsStoreMut,
         vm_externref: VMExternRef,
     ) -> Self {
-        Self(BackendExternRef::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/entities/external/mod.rs b/lib/api/src/entities/external/mod.rs
index 77891b5b5f..7ee104f6eb 100644
--- a/lib/api/src/entities/external/mod.rs
+++ b/lib/api/src/entities/external/mod.rs
@@ -4,8 +4,8 @@ pub use extref::*;
 use wasmer_types::ExternType;
 
 use crate::{
-    vm::VMExtern, AsStoreMut, AsStoreRef, ExportError, Exportable, Function, Global, Memory, Table,
-    Tag,
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Function, Global, Memory, Table, Tag,
+    vm::VMExtern,
 };
 
 /// Trait convert a VMExtern to a Extern
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
index 62427e5108..e1b576623b 100644
--- a/lib/api/src/entities/function/env/inner.rs
+++ b/lib/api/src/entities/function/env/inner.rs
@@ -1,6 +1,8 @@
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
 use crate::{
-    macros::backend::match_rt, AsStoreMut, AsStoreRef, FunctionEnv, FunctionEnvMut, StoreMut,
-    StoreRef,
+    AsStoreMut, AsStoreRef, FunctionEnv, FunctionEnvMut, StoreMut, StoreRef,
+    macros::backend::match_rt,
 };
 use std::{any::Any, marker::PhantomData};
 
@@ -85,11 +87,6 @@ impl<T> BackendFunctionEnv<T> {
         }
     }
 
-    //#[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
@@ -111,7 +108,7 @@ impl<T> BackendFunctionEnv<T> {
     }
 
     /// 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,
     {
@@ -127,6 +124,7 @@ 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>),
@@ -134,6 +132,7 @@ pub enum BackendFunctionEnvMut<'a, T: 'a> {
     #[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>),
@@ -166,17 +165,17 @@ impl<T: Send + 'static> BackendFunctionEnvMut<'_, T> {
     pub fn as_ref(&self) -> FunctionEnv<T> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(ref f) => BackendFunctionEnv::Sys(f.as_ref()).into(),
+            Self::Sys(f) => BackendFunctionEnv::Sys(f.as_ref()).into(),
             #[cfg(feature = "wamr")]
-            Self::Wamr(ref f) => BackendFunctionEnv::Wamr(f.as_ref()).into(),
+            Self::Wamr(f) => BackendFunctionEnv::Wamr(f.as_ref()).into(),
             #[cfg(feature = "wasmi")]
-            Self::Wasmi(ref f) => BackendFunctionEnv::Wasmi(f.as_ref()).into(),
+            Self::Wasmi(f) => BackendFunctionEnv::Wasmi(f.as_ref()).into(),
             #[cfg(feature = "v8")]
-            Self::V8(ref f) => BackendFunctionEnv::V8(f.as_ref()).into(),
+            Self::V8(f) => BackendFunctionEnv::V8(f.as_ref()).into(),
             #[cfg(feature = "js")]
-            Self::Js(ref f) => BackendFunctionEnv::Js(f.as_ref()).into(),
+            Self::Js(f) => BackendFunctionEnv::Js(f.as_ref()).into(),
             #[cfg(feature = "jsc")]
-            Self::Jsc(ref f) => BackendFunctionEnv::Jsc(f.as_ref()).into(),
+            Self::Jsc(f) => BackendFunctionEnv::Jsc(f.as_ref()).into(),
         }
     }
 
@@ -184,32 +183,46 @@ impl<T: Send + 'static> BackendFunctionEnvMut<'_, T> {
     pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
         match self {
             #[cfg(feature = "sys")]
-            Self::Sys(ref mut f) => BackendFunctionEnvMut::Sys(f.as_mut()).into(),
+            Self::Sys(f) => BackendFunctionEnvMut::Sys(f.as_mut()).into(),
             #[cfg(feature = "wamr")]
-            Self::Wamr(ref mut f) => BackendFunctionEnvMut::Wamr(f.as_mut()).into(),
+            Self::Wamr(f) => BackendFunctionEnvMut::Wamr(f.as_mut()).into(),
             #[cfg(feature = "wasmi")]
-            Self::Wasmi(ref mut f) => BackendFunctionEnvMut::Wasmi(f.as_mut()).into(),
+            Self::Wasmi(f) => BackendFunctionEnvMut::Wasmi(f.as_mut()).into(),
             #[cfg(feature = "v8")]
-            Self::V8(ref mut f) => BackendFunctionEnvMut::V8(f.as_mut()).into(),
+            Self::V8(f) => BackendFunctionEnvMut::V8(f.as_mut()).into(),
             #[cfg(feature = "js")]
-            Self::Js(ref mut f) => BackendFunctionEnvMut::Js(f.as_mut()).into(),
+            Self::Js(f) => BackendFunctionEnvMut::Js(f.as_mut()).into(),
             #[cfg(feature = "jsc")]
-            Self::Jsc(ref mut f) => BackendFunctionEnvMut::Jsc(f.as_mut()).into(),
+            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) {
+    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 => f {
-            f.as_store_ref()
+        match_rt!(on self => s {
+            s.as_store_ref()
         })
     }
 }
@@ -238,3 +251,344 @@ where
         })
     }
 }
+
+/// 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
index 5d24212e3b..41b49f942b 100644
--- a/lib/api/src/entities/function/env/mod.rs
+++ b/lib/api/src/entities/function/env/mod.rs
@@ -1,7 +1,9 @@
 pub(crate) mod inner;
 pub(crate) use inner::*;
 
-use crate::{macros::backend::match_rt, AsStoreMut, AsStoreRef, StoreMut, StoreRef};
+#[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)]
@@ -46,7 +48,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// 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,
     {
@@ -80,9 +82,16 @@ 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<'_>) {
         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> {
@@ -109,3 +118,103 @@ where
         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
index db006b9cb2..5caa5b3342 100644
--- a/lib/api/src/entities/function/host/imp.rs
+++ b/lib/api/src/entities/function/host/imp.rs
@@ -1,8 +1,8 @@
 use crate::{
-    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
     AsStoreMut, AsStoreRef, BackendFunctionEnv, BackendFunctionEnvMut, FunctionEnvMut,
     FunctionType, HostFunction, RuntimeError, StoreInner, StoreMut, StoreRef, Value, WithEnv,
     WithoutEnv,
+    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
 };
 
 use std::panic::{self, AssertUnwindSafe};
diff --git a/lib/api/src/entities/function/host/mod.rs b/lib/api/src/entities/function/host/mod.rs
index aadc3555ad..b3dcb0023f 100644
--- a/lib/api/src/entities/function/host/mod.rs
+++ b/lib/api/src/entities/function/host/mod.rs
@@ -1,8 +1,8 @@
 mod imp;
 
 use crate::{
-    vm::{VMFunctionCallback, VMTrampoline},
     BackendKind, WasmTypeList,
+    vm::{VMFunctionCallback, VMTrampoline},
 };
 
 /// The `HostFunction` trait represents the set of functions that
diff --git a/lib/api/src/entities/function/inner.rs b/lib/api/src/entities/function/inner.rs
index 76e4b09253..54bbf742dc 100644
--- a/lib/api/src/entities/function/inner.rs
+++ b/lib/api/src/entities/function/inner.rs
@@ -1,11 +1,15 @@
+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},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, FunctionEnv, FunctionEnvMut,
-    HostFunction, StoreMut, StoreRef, TypedFunction, Value, WasmTypeList, WithEnv, WithoutEnv,
 };
 
 /// A WebAssembly `function` instance.
@@ -247,6 +251,148 @@ impl BackendFunction {
         }
     }
 
+    /// 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
@@ -371,6 +517,29 @@ impl BackendFunction {
         })
     }
 
+    #[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 {
@@ -393,47 +562,47 @@ impl BackendFunction {
     pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
         match &store.as_store_mut().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(s) => Self::Sys(
+            crate::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(
+            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(
+            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(
+            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(
+            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(
+            crate::BackendStore::Jsc(s) => Self::Jsc(unsafe {
                 crate::backend::jsc::entities::function::Function::from_vm_funcref(
                     store,
                     funcref.into_jsc(),
-                ),
-            ),
+                )
+            }),
         }
     }
 
@@ -605,6 +774,23 @@ impl BackendFunction {
     }
 }
 
+#[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 {
diff --git a/lib/api/src/entities/function/mod.rs b/lib/api/src/entities/function/mod.rs
index 1ff92ca609..32668df27a 100644
--- a/lib/api/src/entities/function/mod.rs
+++ b/lib/api/src/entities/function/mod.rs
@@ -10,13 +10,22 @@ pub use host::*;
 pub(crate) mod env;
 pub use env::*;
 
+#[cfg(feature = "experimental-async")]
+pub(crate) mod async_host;
+#[cfg(feature = "experimental-async")]
+pub use async_host::{AsyncFunctionEnv, AsyncHostFunction};
+
+use std::{future::Future, pin::Pin};
+
 use wasmer_types::{FunctionType, RawValue};
 
+#[cfg(feature = "experimental-async")]
+use crate::AsStoreAsync;
 use crate::{
-    error::RuntimeError,
-    vm::{VMExtern, VMExternFunction, VMFuncRef},
     AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, TypedFunction,
     Value, WasmTypeList,
+    error::RuntimeError,
+    vm::{VMExtern, VMExternFunction, VMFuncRef},
 };
 
 /// A WebAssembly `function` instance.
@@ -147,6 +156,78 @@ impl Function {
         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`.
     ///
     /// # Example
@@ -250,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(
@@ -265,7 +362,7 @@ impl Function {
     }
 
     pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
-        Self(BackendFunction::from_vm_funcref(store, funcref))
+        unsafe { Self(BackendFunction::from_vm_funcref(store, funcref)) }
     }
 
     /// Transform this WebAssembly function into a typed function.
diff --git a/lib/api/src/entities/global/inner.rs b/lib/api/src/entities/global/inner.rs
index 887864b205..bb867eeba4 100644
--- a/lib/api/src/entities/global/inner.rs
+++ b/lib/api/src/entities/global/inner.rs
@@ -1,10 +1,10 @@
 use crate::{
+    ExportError, Exportable, Extern,
     error::RuntimeError,
     macros::backend::{gen_rt_ty, match_rt},
     store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
     value::Value,
     vm::{VMExtern, VMExternGlobal},
-    ExportError, Exportable, Extern,
 };
 use wasmer_types::{GlobalType, Mutability};
 
diff --git a/lib/api/src/entities/global/mod.rs b/lib/api/src/entities/global/mod.rs
index 0cf479b7cc..93b3fc5025 100644
--- a/lib/api/src/entities/global/mod.rs
+++ b/lib/api/src/entities/global/mod.rs
@@ -1,9 +1,9 @@
 use crate::{
+    ExportError, Exportable, Extern,
     error::RuntimeError,
     store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
     value::Value,
     vm::{VMExtern, VMExternGlobal},
-    ExportError, Exportable, Extern,
 };
 use wasmer_types::{GlobalType, Mutability};
 
diff --git a/lib/api/src/entities/imports.rs b/lib/api/src/entities/imports.rs
index d0bd6b19c5..2efb2f2606 100644
--- a/lib/api/src/entities/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::{error::LinkError, Exports, Extern, 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.
@@ -306,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]
diff --git a/lib/api/src/entities/instance.rs b/lib/api/src/entities/instance.rs
index 0a2e7ac18b..761e160e9c 100644
--- a/lib/api/src/entities/instance.rs
+++ b/lib/api/src/entities/instance.rs
@@ -1,6 +1,6 @@
 use crate::{
-    error::InstantiationError, exports::Exports, imports::Imports, macros::backend::gen_rt_ty,
-    module::Module, store::AsStoreMut, Extern,
+    Extern, error::InstantiationError, exports::Exports, imports::Imports,
+    macros::backend::gen_rt_ty, module::Module, store::AsStoreMut,
 };
 
 /// A WebAssembly Instance is a stateful, executable
diff --git a/lib/api/src/entities/memory/buffer/inner.rs b/lib/api/src/entities/memory/buffer/inner.rs
index 6823b331ba..4cc3c199d2 100644
--- a/lib/api/src/entities/memory/buffer/inner.rs
+++ b/lib/api/src/entities/memory/buffer/inner.rs
@@ -1,8 +1,8 @@
 use std::{marker::PhantomData, mem::MaybeUninit};
 
 use crate::{
-    macros::backend::{gen_rt_ty, match_rt},
     MemoryAccessError,
+    macros::backend::{gen_rt_ty, match_rt},
 };
 
 /// Underlying buffer for a memory.
diff --git a/lib/api/src/entities/memory/inner.rs b/lib/api/src/entities/memory/inner.rs
index f6ec7c471d..74dd52c960 100644
--- a/lib/api/src/entities/memory/inner.rs
+++ b/lib/api/src/entities/memory/inner.rs
@@ -2,9 +2,9 @@ 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},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
 };
 
 gen_rt_ty!(Memory
diff --git a/lib/api/src/entities/memory/mod.rs b/lib/api/src/entities/memory/mod.rs
index 168aacc57d..e869b2fb70 100644
--- a/lib/api/src/entities/memory/mod.rs
+++ b/lib/api/src/entities/memory/mod.rs
@@ -2,8 +2,8 @@ pub use shared::SharedMemory;
 use wasmer_types::{MemoryError, MemoryType, Pages};
 
 use crate::{
-    vm::{VMExtern, VMExternMemory, VMMemory},
     AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
+    vm::{VMExtern, VMExternMemory, VMMemory},
 };
 
 pub(crate) mod buffer;
diff --git a/lib/api/src/entities/memory/shared.rs b/lib/api/src/entities/memory/shared.rs
index 45a31eb8f4..9d7bac06c2 100644
--- a/lib/api/src/entities/memory/shared.rs
+++ b/lib/api/src/entities/memory/shared.rs
@@ -1,9 +1,9 @@
 use wasmer_types::MemoryError;
 
 use crate::{
+    Memory,
     error::AtomicsError,
     location::{MemoryLocation, SharedMemoryOps},
-    Memory,
 };
 
 /// A handle that exposes operations only relevant for shared memories.
diff --git a/lib/api/src/entities/memory/view/inner.rs b/lib/api/src/entities/memory/view/inner.rs
index 6297d6802a..c0ff910388 100644
--- a/lib/api/src/entities/memory/view/inner.rs
+++ b/lib/api/src/entities/memory/view/inner.rs
@@ -2,9 +2,9 @@ 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},
-    AsStoreRef, Memory, MemoryAccessError,
 };
 
 /// A WebAssembly `memory` view.
@@ -90,7 +90,7 @@ impl<'a> BackendMemoryView<'a> {
     #[inline]
     pub unsafe fn data_unchecked(&self) -> &[u8] {
         match_rt!(on self => s {
-            s.data_unchecked()
+            unsafe { s.data_unchecked() }
         })
     }
 
@@ -108,7 +108,7 @@ impl<'a> BackendMemoryView<'a> {
     #[inline]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
         match_rt!(on self => s {
-            s.data_unchecked_mut()
+            unsafe { s.data_unchecked_mut() }
         })
     }
 
diff --git a/lib/api/src/entities/memory/view/mod.rs b/lib/api/src/entities/memory/view/mod.rs
index 32e55ce4b1..8f16105dc5 100644
--- a/lib/api/src/entities/memory/view/mod.rs
+++ b/lib/api/src/entities/memory/view/mod.rs
@@ -1,7 +1,7 @@
 use std::{mem::MaybeUninit, ops::Range};
 use wasmer_types::Pages;
 
-use crate::{buffer::MemoryBuffer, AsStoreRef, Memory, MemoryAccessError};
+use crate::{AsStoreRef, Memory, MemoryAccessError, buffer::MemoryBuffer};
 
 pub(crate) mod inner;
 pub(crate) use inner::*;
@@ -43,7 +43,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.0.data_unchecked() }
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -58,7 +58,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 { self.0.data_unchecked_mut() }
     }
 
     /// Returns the size (in [`Pages`]) of the `Memory`.
diff --git a/lib/api/src/entities/module/inner.rs b/lib/api/src/entities/module/inner.rs
index 66afadc0ed..56b7c54278 100644
--- a/lib/api/src/entities/module/inner.rs
+++ b/lib/api/src/entities/module/inner.rs
@@ -13,9 +13,9 @@ use wasmer_types::{
 };
 
 use crate::{
+    AsEngineRef,
     macros::backend::{gen_rt_ty, match_rt},
     utils::IntoBytes,
-    AsEngineRef,
 };
 
 /// A WebAssembly Module contains stateless WebAssembly
@@ -115,44 +115,62 @@ impl BackendModule {
     ) -> Result<Self, CompileError> {
         match engine.as_engine_ref().inner.be {
             #[cfg(feature = "sys")]
-            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
-                crate::backend::sys::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            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(_) => Ok(Self::Wamr(
-                crate::backend::wamr::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            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(_) => Ok(Self::Wasmi(
-                crate::backend::wasmi::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            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(_) => Ok(Self::V8(
-                crate::backend::v8::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            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(_) => Ok(Self::Js(
-                crate::backend::js::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            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(_) => Ok(Self::Jsc(
-                crate::backend::jsc::entities::module::Module::from_binary_unchecked(
-                    engine, binary,
-                )?,
-            )),
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::from_binary_unchecked(
+                        engine, binary,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
         }
     }
 
@@ -279,38 +297,60 @@ impl BackendModule {
     ) -> Result<Self, DeserializeError> {
         match engine.as_engine_ref().inner.be {
             #[cfg(feature = "sys")]
-            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
-                crate::backend::sys::entities::module::Module::deserialize_unchecked(
-                    engine, bytes,
-                )?,
-            )),
+            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(_) => Ok(Self::Wamr(
-                crate::backend::wamr::entities::module::Module::deserialize_unchecked(
-                    engine, bytes,
-                )?,
-            )),
+            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(_) => Ok(Self::Wasmi(
-                crate::backend::wasmi::entities::module::Module::deserialize_unchecked(
-                    engine, bytes,
-                )?,
-            )),
+            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(_) => Ok(Self::V8(
-                crate::backend::v8::entities::module::Module::deserialize_unchecked(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Js(
-                crate::backend::js::entities::module::Module::deserialize_unchecked(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Jsc(
-                crate::backend::jsc::entities::module::Module::deserialize_unchecked(
-                    engine, bytes,
-                )?,
-            )),
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_unchecked(
+                        engine, bytes,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
         }
     }
 
@@ -346,30 +386,48 @@ impl BackendModule {
     ) -> Result<Self, DeserializeError> {
         match engine.as_engine_ref().inner.be {
             #[cfg(feature = "sys")]
-            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
-                crate::backend::sys::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Wamr(
-                crate::backend::wamr::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Wasmi(
-                crate::backend::wasmi::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::V8(
-                crate::backend::v8::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Js(
-                crate::backend::js::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            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(_) => Ok(Self::Jsc(
-                crate::backend::jsc::entities::module::Module::deserialize(engine, bytes)?,
-            )),
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize(engine, bytes)?
+                };
+                Ok(Self::Jsc(module))
+            }
         }
     }
 
@@ -380,8 +438,8 @@ impl BackendModule {
     ///
     /// ```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(())
     /// # }
@@ -397,34 +455,60 @@ impl BackendModule {
     ) -> Result<Self, DeserializeError> {
         match engine.as_engine_ref().inner.be {
             #[cfg(feature = "sys")]
-            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
-                crate::backend::sys::entities::module::Module::deserialize_from_file(engine, path)?,
-            )),
+            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(_) => Ok(Self::Wamr(
-                crate::backend::wamr::entities::module::Module::deserialize_from_file(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::Wasmi(
-                crate::backend::wasmi::entities::module::Module::deserialize_from_file(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::V8(
-                crate::backend::v8::entities::module::Module::deserialize_from_file(engine, path)?,
-            )),
+            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(_) => Ok(Self::Js(
-                crate::backend::js::entities::module::Module::deserialize_from_file(engine, path)?,
-            )),
+            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(_) => Ok(Self::Jsc(
-                crate::backend::jsc::entities::module::Module::deserialize_from_file(engine, path)?,
-            )),
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_from_file(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
         }
     }
 
@@ -441,8 +525,8 @@ impl BackendModule {
     ///
     /// ```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(())
     /// # }
@@ -454,42 +538,60 @@ impl BackendModule {
     ) -> Result<Self, DeserializeError> {
         match engine.as_engine_ref().inner.be {
             #[cfg(feature = "sys")]
-            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
-                crate::backend::sys::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::Wamr(
-                crate::backend::wamr::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::Wasmi(
-                crate::backend::wasmi::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::V8(
-                crate::backend::v8::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::Js(
-                crate::backend::js::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            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(_) => Ok(Self::Jsc(
-                crate::backend::jsc::entities::module::Module::deserialize_from_file_unchecked(
-                    engine, path,
-                )?,
-            )),
+            crate::BackendEngine::Jsc(_) => {
+                let module = unsafe {
+                    crate::backend::jsc::entities::module::Module::deserialize_from_file_unchecked(
+                        engine, path,
+                    )?
+                };
+                Ok(Self::Jsc(module))
+            }
         }
     }
 
diff --git a/lib/api/src/entities/module/mod.rs b/lib/api/src/entities/module/mod.rs
index 1162d03172..daa3de0312 100644
--- a/lib/api/src/entities/module/mod.rs
+++ b/lib/api/src/entities/module/mod.rs
@@ -15,7 +15,7 @@ use wasmer_types::{
     ModuleInfo, SerializeError,
 };
 
-use crate::{macros::backend::match_rt, utils::IntoBytes, AsEngineRef};
+use crate::{AsEngineRef, macros::backend::match_rt, utils::IntoBytes};
 
 /// IO errors that can happen while compiling a [`Module`].
 #[derive(Error, Debug)]
@@ -142,7 +142,7 @@ impl Module {
         engine: &impl AsEngineRef,
         binary: &[u8],
     ) -> Result<Self, CompileError> {
-        BackendModule::from_binary_unchecked(engine, binary).map(Self)
+        unsafe { BackendModule::from_binary_unchecked(engine, binary) }.map(Self)
     }
 
     /// Validates a new WebAssembly Module given the configuration
@@ -234,7 +234,7 @@ impl Module {
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
-        BackendModule::deserialize_unchecked(engine, bytes).map(Self)
+        unsafe { BackendModule::deserialize_unchecked(engine, bytes) }.map(Self)
     }
 
     /// Deserializes a serialized Module binary into a `Module`.
@@ -266,7 +266,7 @@ impl Module {
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
-        BackendModule::deserialize_unchecked(engine, bytes).map(Self)
+        unsafe { BackendModule::deserialize_unchecked(engine, bytes) }.map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -276,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(())
     /// # }
@@ -290,7 +290,7 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        BackendModule::deserialize_from_file(engine, path).map(Self)
+        unsafe { BackendModule::deserialize_from_file(engine, path) }.map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -306,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(())
     /// # }
@@ -316,7 +316,7 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        BackendModule::deserialize_from_file_unchecked(engine, path).map(Self)
+        unsafe { BackendModule::deserialize_from_file_unchecked(engine, path) }.map(Self)
     }
 
     /// Returns the name of the current module.
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
index c41bdbf7a8..c977b01acb 100644
--- a/lib/api/src/entities/store/inner.rs
+++ b/lib/api/src/entities/store/inner.rs
@@ -1,10 +1,10 @@
 use crate::{
+    AsStoreMut, AsStoreRef, StoreRef,
     entities::{
         engine::{AsEngineRef, Engine},
         store::{StoreMut, StoreObjects},
     },
     macros::backend::{gen_rt_ty, match_rt},
-    AsStoreMut,
 };
 
 #[cfg(feature = "sys")]
@@ -29,6 +29,21 @@ impl std::fmt::Debug for StoreInner {
     }
 }
 
+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<
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
index cc403861f4..e1aee0709f 100644
--- a/lib/api/src/entities/store/mod.rs
+++ b/lib/api/src/entities/store/mod.rs
@@ -1,17 +1,39 @@
 //! 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;
 
@@ -108,6 +130,16 @@ impl 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 {
diff --git a/lib/api/src/entities/store/obj.rs b/lib/api/src/entities/store/obj.rs
index 8fa28ed5fe..215ec2b8a5 100644
--- a/lib/api/src/entities/store/obj.rs
+++ b/lib/api/src/entities/store/obj.rs
@@ -1,6 +1,6 @@
 use wasmer_types::StoreId;
 
-use crate::{macros::backend::match_rt, BackendStore};
+use crate::{BackendStore, macros::backend::match_rt};
 
 /// Set of objects managed by a context.
 #[derive(Debug)]
@@ -37,16 +37,16 @@ impl StoreObjects {
     pub fn same(a: &Self, b: &Self) -> bool {
         match (a, b) {
             #[cfg(feature = "sys")]
-            (Self::Sys(ref a), Self::Sys(ref b)) => a.id() == b.id(),
+            (Self::Sys(a), Self::Sys(b)) => a.id() == b.id(),
             #[cfg(feature = "wamr")]
-            (Self::Wamr(ref a), Self::Wamr(ref b)) => a.id() == b.id(),
+            (Self::Wamr(a), Self::Wamr(b)) => a.id() == b.id(),
             #[cfg(feature = "v8")]
-            (Self::V8(ref a), Self::V8(ref b)) => a.id() == b.id(),
+            (Self::V8(a), Self::V8(b)) => a.id() == b.id(),
             #[cfg(feature = "js")]
-            (Self::Js(ref a), Self::Js(ref b)) => a.id() == b.id(),
+            (Self::Js(a), Self::Js(b)) => a.id() == b.id(),
 
             #[cfg(feature = "jsc")]
-            (Self::Jsc(ref a), Self::Jsc(ref b)) => a.id() == b.id(),
+            (Self::Jsc(a), Self::Jsc(b)) => a.id() == b.id(),
 
             _ => panic!(
                 "Incompatible `StoreObjects` instance: {}, {}!",
diff --git a/lib/api/src/entities/store/store_ref.rs b/lib/api/src/entities/store/store_ref.rs
index 1dae7b5ead..42ad59ec12 100644
--- a/lib/api/src/entities/store/store_ref.rs
+++ b/lib/api/src/entities/store/store_ref.rs
@@ -1,7 +1,9 @@
 use std::ops::{Deref, DerefMut};
 
-use super::{inner::StoreInner, StoreObjects};
+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};
 
@@ -63,7 +65,9 @@ impl StoreMut<'_> {
 
     #[allow(unused)]
     pub(crate) unsafe fn from_raw(raw: *mut StoreInner) -> Self {
-        Self { inner: &mut *raw }
+        Self {
+            inner: unsafe { &mut *raw },
+        }
     }
 
     #[allow(unused)]
@@ -88,6 +92,17 @@ impl StoreMut<'_> {
 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`].
diff --git a/lib/api/src/entities/table/inner.rs b/lib/api/src/entities/table/inner.rs
index 5cbe35b893..13e6f86e1d 100644
--- a/lib/api/src/entities/table/inner.rs
+++ b/lib/api/src/entities/table/inner.rs
@@ -1,11 +1,11 @@
 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},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
 };
 /// A WebAssembly `table` instance.
 ///
@@ -254,7 +254,7 @@ mod test {
         ignore = "growing tables in v8 is not currently supported"
     )]
     fn table_grow_issue_3197() {
-        use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+        use crate::{Instance, Module, Store, Table, TableType, Type, Value, imports};
 
         const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
 
diff --git a/lib/api/src/entities/table/mod.rs b/lib/api/src/entities/table/mod.rs
index 0ee1934df6..bcb05aa5e2 100644
--- a/lib/api/src/entities/table/mod.rs
+++ b/lib/api/src/entities/table/mod.rs
@@ -4,10 +4,10 @@ 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},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
 };
 
 /// A WebAssembly `table` instance.
@@ -135,7 +135,7 @@ mod test {
         ignore = "growing tables in v8 is not currently supported"
     )]
     fn table_grow_issue_3197() {
-        use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+        use crate::{Instance, Module, Store, Table, TableType, Type, Value, imports};
 
         const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
 
diff --git a/lib/api/src/entities/tag/inner.rs b/lib/api/src/entities/tag/inner.rs
index 1a30f1ade0..5d05c4bbd1 100644
--- a/lib/api/src/entities/tag/inner.rs
+++ b/lib/api/src/entities/tag/inner.rs
@@ -1,9 +1,9 @@
 use wasmer_types::{TagType, Type};
 
 use crate::{
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
     macros::backend::{gen_rt_ty, match_rt},
     vm::{VMExtern, VMExternTag},
-    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
 };
 
 /// A WebAssembly `global` instance.
diff --git a/lib/api/src/entities/tag/mod.rs b/lib/api/src/entities/tag/mod.rs
index e670d0a4fa..794d0b5d9c 100644
--- a/lib/api/src/entities/tag/mod.rs
+++ b/lib/api/src/entities/tag/mod.rs
@@ -3,8 +3,8 @@ pub(crate) use inner::*;
 use wasmer_types::{TagType, Type};
 
 use crate::{
-    vm::{VMExtern, VMExternTag},
     AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
+    vm::{VMExtern, VMExternTag},
 };
 
 /// A WebAssembly `tag` instance.
diff --git a/lib/api/src/entities/trap.rs b/lib/api/src/entities/trap.rs
index 06af0c198e..8578b96051 100644
--- a/lib/api/src/entities/trap.rs
+++ b/lib/api/src/entities/trap.rs
@@ -1,6 +1,8 @@
 use std::{any::Any, error::Error, fmt::Debug};
 
-use crate::{macros::backend::match_rt, RuntimeError};
+#[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)]
@@ -87,6 +89,45 @@ impl BackendTrap {
             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 {
diff --git a/lib/api/src/entities/value.rs b/lib/api/src/entities/value.rs
index 4ef22e45e4..06ec15ec82 100644
--- a/lib/api/src/entities/value.rs
+++ b/lib/api/src/entities/value.rs
@@ -1,9 +1,9 @@
 use wasmer_types::{RawValue, Type};
 
 use crate::{
-    entities::{ExceptionRef, ExternRef, Function},
-    vm::{VMExceptionRef, VMExternRef, VMFuncRef},
     AsStoreRef, Tag,
+    entities::{Exception, ExternRef, Function},
+    vm::{VMExceptionRef, VMExternRef, VMFuncRef},
 };
 
 /// WebAssembly computations manipulate values of basic value types:
@@ -41,7 +41,7 @@ pub enum Value {
     FuncRef(Option<Function>),
 
     /// A nullable first-class reference to a WebAssembly exception.
-    ExceptionRef(Option<ExceptionRef>),
+    ExceptionRef(Option<Exception>),
 }
 
 macro_rules! accessors {
@@ -97,7 +97,7 @@ impl Value {
             Self::F64(f64) => RawValue { f64 },
             Self::V128(u128) => RawValue { u128 },
             Self::ExceptionRef(Some(ref f)) => f.vm_exceptionref().into_raw(),
-            Self::ExceptionRef(None) => RawValue { funcref: 0 },
+            Self::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(),
@@ -115,126 +115,136 @@ impl Value {
         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::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(
-                    crate::backend::sys::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::Sys)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::wamr::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::Wamr)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::wasmi::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::Wasmi)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::v8::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::V8)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::js::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::Js)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::jsc::vm::VMFuncRef::from_raw(raw)
-                        .map(VMFuncRef::Jsc)
-                        .map(|f| Function::from_vm_funcref(store, f)),
-                ),
+                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(
-                    crate::backend::sys::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::Sys)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::wamr::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::Wamr)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::wasmi::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::Wasmi)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::v8::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::V8)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::js::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::Js)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::jsc::vm::VMExternRef::from_raw(raw)
-                        .map(VMExternRef::Jsc)
-                        .map(|f| ExternRef::from_vm_externref(store, f)),
-                ),
+                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(
-                    crate::backend::sys::vm::VMExceptionRef::from_raw(raw)
-                        .map(VMExceptionRef::Sys)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                    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(
-                    crate::backend::wamr::vm::VMExceptionRef::from_raw(raw)
+                    unsafe { crate::backend::wamr::vm::VMExceptionRef::from_raw(raw) }
                         .map(VMExceptionRef::Wamr)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                        .map(Exception::from_vm_exceptionref),
                 ),
                 #[cfg(feature = "wasmi")]
                 crate::BackendStore::Wasmi(_) => Self::ExceptionRef(
-                    crate::backend::wasmi::vm::VMExceptionRef::from_raw(raw)
+                    unsafe { crate::backend::wasmi::vm::VMExceptionRef::from_raw(raw) }
                         .map(VMExceptionRef::Wasmi)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                        .map(Exception::from_vm_exceptionref),
                 ),
 
                 #[cfg(feature = "v8")]
                 crate::BackendStore::V8(_) => Self::ExceptionRef(
-                    crate::backend::v8::vm::VMExceptionRef::from_raw(raw)
+                    unsafe { crate::backend::v8::vm::VMExceptionRef::from_raw(raw) }
                         .map(VMExceptionRef::V8)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                        .map(Exception::from_vm_exceptionref),
                 ),
                 #[cfg(feature = "js")]
                 crate::BackendStore::Js(_) => Self::ExceptionRef(
-                    crate::backend::js::vm::VMExceptionRef::from_raw(raw)
+                    unsafe { crate::backend::js::vm::VMExceptionRef::from_raw(raw) }
                         .map(VMExceptionRef::Js)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                        .map(Exception::from_vm_exceptionref),
                 ),
                 #[cfg(feature = "jsc")]
                 crate::BackendStore::Jsc(_) => Self::ExceptionRef(
-                    crate::backend::jsc::vm::VMExceptionRef::from_raw(raw)
+                    unsafe { crate::backend::jsc::vm::VMExceptionRef::from_raw(raw) }
                         .map(VMExceptionRef::Jsc)
-                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                        .map(Exception::from_vm_exceptionref),
                 ),
             },
         }
@@ -387,14 +397,14 @@ impl From<Option<ExternRef>> for Value {
     }
 }
 
-impl From<ExceptionRef> for Value {
-    fn from(val: ExceptionRef) -> Self {
+impl From<Exception> for Value {
+    fn from(val: Exception) -> Self {
         Self::ExceptionRef(Some(val))
     }
 }
 
-impl From<Option<ExceptionRef>> for Value {
-    fn from(val: Option<ExceptionRef>) -> Self {
+impl From<Option<Exception>> for Value {
+    fn from(val: Option<Exception>) -> Self {
         Self::ExceptionRef(val)
     }
 }
@@ -477,7 +487,7 @@ impl TryFrom<Value> for Option<ExternRef> {
     }
 }
 
-impl TryFrom<Value> for Option<ExceptionRef> {
+impl TryFrom<Value> for Option<Exception> {
     type Error = &'static str;
 
     fn try_from(value: Value) -> Result<Self, Self::Error> {
diff --git a/lib/api/src/error.rs b/lib/api/src/error.rs
index 35400775b7..f80ffb67da 100644
--- a/lib/api/src/error.rs
+++ b/lib/api/src/error.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 use thiserror::Error;
 use wasmer_types::{FrameInfo, ImportError, TrapCode};
 
-use crate::BackendTrap as Trap;
+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).
@@ -18,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),
@@ -37,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),
 
@@ -153,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 {
@@ -198,25 +218,32 @@ impl RuntimeError {
     pub fn is<T: std::error::Error + 'static>(&self) -> bool {
         self.inner.source.is::<T>()
     }
-}
 
-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()
+    /// Returns true if the `RuntimeError` is an uncaught exception.
+    pub fn is_exception(&self) -> bool {
+        self.inner.source.is_exception()
     }
-}
 
-impl std::fmt::Display for RuntimeError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "RuntimeError: {}", self.message())?;
-        let trace = self.trace();
+    /// If 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)?;
@@ -238,6 +265,52 @@ impl std::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 {
diff --git a/lib/api/src/lib.rs b/lib/api/src/lib.rs
index 3627094333..c85f05cfa0 100644
--- a/lib/api/src/lib.rs
+++ b/lib/api/src/lib.rs
@@ -72,11 +72,11 @@
 //!
 //! * **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`].
@@ -302,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),")]
@@ -428,7 +428,7 @@ mod utils;
 pub use utils::*;
 
 mod entities;
-pub use entities::memory::{location::MemoryLocation, MemoryView};
+pub use entities::memory::{MemoryView, location::MemoryLocation};
 pub use entities::*;
 
 mod error;
@@ -439,11 +439,11 @@ pub use backend::*;
 mod vm;
 
 pub use wasmer_types::{
-    is_wasm, Bytes, CompileError, DeserializeError, ExportIndex, ExportType, ExternType, FrameInfo,
+    Bytes, CompileError, DeserializeError, ExportIndex, ExportType, ExternType, FrameInfo,
     FunctionType, GlobalInit, GlobalType, ImportType, LocalFunctionIndex, MemoryError, MemoryStyle,
     MemoryType, Mutability, OnCalledAction, Pages, ParseCpuFeatureError, SerializeError,
-    TableStyle, TableType, TagKind, TagType, Type, ValueType, WasmError, WasmResult,
-    WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
+    TableStyle, TableType, TagKind, TagType, Type, ValueType, WASM_MAX_PAGES, WASM_MIN_PAGES,
+    WASM_PAGE_SIZE, WasmError, WasmResult, is_wasm,
 };
 
 #[cfg(feature = "wasmparser")]
diff --git a/lib/api/src/utils/macros/backend.rs b/lib/api/src/utils/macros/backend.rs
index 32b77c23eb..5faf704495 100644
--- a/lib/api/src/utils/macros/backend.rs
+++ b/lib/api/src/utils/macros/backend.rs
@@ -37,6 +37,7 @@ macro_rules! gen_rt_ty {
         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.
diff --git a/lib/api/src/utils/mem/access.rs b/lib/api/src/utils/mem/access.rs
index 8b921b6aaa..71da1165b3 100644
--- a/lib/api/src/utils/mem/access.rs
+++ b/lib/api/src/utils/mem/access.rs
@@ -2,8 +2,8 @@ use std::mem::{self, MaybeUninit};
 use std::slice;
 
 use crate::{
-    utils::mem::{WasmRef, WasmSlice},
     MemoryAccessError,
+    utils::mem::{WasmRef, WasmSlice},
 };
 
 pub(crate) enum SliceCow<'a, T> {
@@ -118,10 +118,10 @@ 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();
-            }
+        if let SliceCow::Owned(buf, modified) = &self.buf
+            && *modified
+        {
+            self.slice.write_slice(buf.as_ref()).ok();
         }
     }
 }
@@ -191,10 +191,10 @@ where
     T: wasmer_types::ValueType,
 {
     fn drop(&mut self) {
-        if let RefCow::Owned(val, modified) = &self.buf {
-            if *modified {
-                self.ptr.write(*val).ok();
-            }
+        if let RefCow::Owned(val, modified) = &self.buf
+            && *modified
+        {
+            self.ptr.write(*val).ok();
         }
     }
 }
diff --git a/lib/api/src/utils/mem/ptr.rs b/lib/api/src/utils/mem/ptr.rs
index 257e2a1cb2..dcb089297d 100644
--- a/lib/api/src/utils/mem/ptr.rs
+++ b/lib/api/src/utils/mem/ptr.rs
@@ -2,8 +2,8 @@ use std::marker::PhantomData;
 use wasmer_types::{Memory32, Memory64, MemorySize, ValueType};
 
 use crate::{
-    access::WasmRefAccess, view::MemoryView, AsStoreRef, FromToNativeWasmType, MemoryAccessError,
-    NativeWasmTypeInto, WasmRef, WasmSlice,
+    AsStoreRef, FromToNativeWasmType, MemoryAccessError, NativeWasmTypeInto, WasmRef, WasmSlice,
+    access::WasmRefAccess, view::MemoryView,
 };
 
 /// Alias for `WasmPtr<T, Memory64>.
diff --git a/lib/api/src/utils/native/convert.rs b/lib/api/src/utils/native/convert.rs
index e776ce6854..05c4a1b977 100644
--- a/lib/api/src/utils/native/convert.rs
+++ b/lib/api/src/utils/native/convert.rs
@@ -3,8 +3,8 @@ use wasmer_types::{RawValue, Type};
 
 use crate::store::AsStoreRef;
 use crate::{
-    vm::{VMExternRef, VMFuncRef},
     ExternRef, Function, TypedFunction,
+    vm::{VMExternRef, VMFuncRef},
 };
 
 use std::error::Error;
@@ -52,7 +52,7 @@ impl NativeWasmTypeInto for i32 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i32
+        unsafe { raw.i32 }
     }
 }
 
@@ -74,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 _ }
     }
 }
 
@@ -96,7 +96,7 @@ impl NativeWasmTypeInto for i64 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.i64
+        unsafe { raw.i64 }
     }
 }
 
@@ -118,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 _ }
     }
 }
 
@@ -140,7 +140,7 @@ impl NativeWasmTypeInto for f32 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.f32
+        unsafe { raw.f32 }
     }
 }
 
@@ -162,7 +162,7 @@ impl NativeWasmTypeInto for f64 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.f64
+        unsafe { raw.f64 }
     }
 }
 
@@ -184,7 +184,7 @@ impl NativeWasmTypeInto for u128 {
 
     #[inline]
     unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        raw.u128
+        unsafe { raw.u128 }
     }
 }
 
@@ -198,36 +198,36 @@ impl NativeWasmTypeInto for Option<ExternRef> {
     unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
         match store.as_store_ref().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => {
+            crate::BackendStore::Sys(_) => unsafe {
                 wasmer_vm::VMExternRef::from_raw(RawValue { externref: abi }).map(VMExternRef::Sys)
-            }
+            },
             #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => {
+            crate::BackendStore::Wamr(_) => unsafe {
                 crate::backend::wamr::vm::VMExternRef::from_raw(RawValue { externref: abi })
                     .map(VMExternRef::Wamr)
-            }
+            },
             #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => {
+            crate::BackendStore::Wasmi(_) => unsafe {
                 crate::backend::wasmi::vm::VMExternRef::from_raw(RawValue { externref: abi })
                     .map(VMExternRef::Wasmi)
-            }
+            },
             #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => {
+            crate::BackendStore::V8(_) => unsafe {
                 crate::backend::v8::vm::VMExternRef::from_raw(RawValue { externref: abi })
                     .map(VMExternRef::V8)
-            }
+            },
             #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => {
+            crate::BackendStore::Js(_) => unsafe {
                 crate::backend::js::vm::VMExternRef::from_raw(RawValue { externref: abi })
                     .map(VMExternRef::Js)
-            }
+            },
             #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => {
+            crate::BackendStore::Jsc(_) => unsafe {
                 crate::backend::jsc::vm::VMExternRef::from_raw(RawValue { externref: abi })
                     .map(VMExternRef::Jsc)
-            }
+            },
         }
-        .map(|e| ExternRef::from_vm_externref(store, e))
+        .map(|e| unsafe { ExternRef::from_vm_externref(store, e) })
     }
 
     #[inline]
@@ -244,31 +244,31 @@ impl NativeWasmTypeInto for Option<ExternRef> {
     unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
         match store.as_store_ref().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => {
+            crate::BackendStore::Sys(_) => unsafe {
                 wasmer_vm::VMExternRef::from_raw(raw).map(VMExternRef::Sys)
-            }
+            },
             #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => {
+            crate::BackendStore::Wamr(_) => unsafe {
                 crate::backend::wamr::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wamr)
-            }
+            },
             #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => {
+            crate::BackendStore::Wasmi(_) => unsafe {
                 crate::backend::wasmi::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wasmi)
-            }
+            },
             #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => {
+            crate::BackendStore::V8(_) => unsafe {
                 crate::backend::v8::vm::VMExternRef::from_raw(raw).map(VMExternRef::V8)
-            }
+            },
             #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => {
+            crate::BackendStore::Js(_) => unsafe {
                 crate::backend::js::vm::VMExternRef::from_raw(raw).map(VMExternRef::Js)
-            }
+            },
             #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => {
+            crate::BackendStore::Jsc(_) => unsafe {
                 crate::backend::jsc::vm::VMExternRef::from_raw(raw).map(VMExternRef::Jsc)
-            }
+            },
         }
-        .map(|e| ExternRef::from_vm_externref(store, e))
+        .map(|e| unsafe { ExternRef::from_vm_externref(store, e) })
     }
 }
 
@@ -292,36 +292,36 @@ impl NativeWasmTypeInto for Option<Function> {
     unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
         match store.as_store_ref().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => {
+            crate::BackendStore::Sys(_) => unsafe {
                 wasmer_vm::VMFuncRef::from_raw(RawValue { funcref: abi }).map(VMFuncRef::Sys)
-            }
+            },
             #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => {
+            crate::BackendStore::Wamr(_) => unsafe {
                 crate::backend::wamr::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
                     .map(VMFuncRef::Wamr)
-            }
+            },
             #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => {
+            crate::BackendStore::Wasmi(_) => unsafe {
                 crate::backend::wasmi::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
                     .map(VMFuncRef::Wasmi)
-            }
+            },
             #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => {
+            crate::BackendStore::V8(_) => unsafe {
                 crate::backend::v8::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
                     .map(VMFuncRef::V8)
-            }
+            },
             #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => {
+            crate::BackendStore::Js(_) => unsafe {
                 crate::backend::js::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
                     .map(VMFuncRef::Js)
-            }
+            },
             #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => {
+            crate::BackendStore::Jsc(_) => unsafe {
                 crate::backend::jsc::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
                     .map(VMFuncRef::Jsc)
-            }
+            },
         }
-        .map(|f| Function::from_vm_funcref(store, f))
+        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
     }
 
     #[inline]
@@ -340,29 +340,31 @@ impl NativeWasmTypeInto for Option<Function> {
     unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
         match store.as_store_ref().inner.store {
             #[cfg(feature = "sys")]
-            crate::BackendStore::Sys(_) => wasmer_vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Sys),
+            crate::BackendStore::Sys(_) => unsafe {
+                wasmer_vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Sys)
+            },
             #[cfg(feature = "wamr")]
-            crate::BackendStore::Wamr(_) => {
+            crate::BackendStore::Wamr(_) => unsafe {
                 crate::backend::wamr::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wamr)
-            }
+            },
             #[cfg(feature = "wasmi")]
-            crate::BackendStore::Wasmi(_) => {
+            crate::BackendStore::Wasmi(_) => unsafe {
                 crate::backend::wasmi::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wasmi)
-            }
+            },
             #[cfg(feature = "v8")]
-            crate::BackendStore::V8(_) => {
+            crate::BackendStore::V8(_) => unsafe {
                 crate::backend::v8::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::V8)
-            }
+            },
             #[cfg(feature = "js")]
-            crate::BackendStore::Js(_) => {
+            crate::BackendStore::Js(_) => unsafe {
                 crate::backend::js::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Js)
-            }
+            },
             #[cfg(feature = "jsc")]
-            crate::BackendStore::Jsc(_) => {
+            crate::BackendStore::Jsc(_) => unsafe {
                 crate::backend::jsc::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Jsc)
-            }
+            },
         }
-        .map(|f| Function::from_vm_funcref(store, f))
+        .map(|f| unsafe { Function::from_vm_funcref(store, f) })
     }
 }
 
@@ -477,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))
     }
 }
 
@@ -491,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))
     }
 }
 
@@ -760,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)]
@@ -800,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)
+                        }
                     ),*
                 )
             }
@@ -826,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/typed_func.rs b/lib/api/src/utils/native/typed_func.rs
index 76ff59db95..546858309e 100644
--- a/lib/api/src/utils/native/typed_func.rs
+++ b/lib/api/src/utils/native/typed_func.rs
@@ -7,10 +7,13 @@
 //! 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::{
-    store::AsStoreRef, AsStoreMut, BackendStore, FromToNativeWasmType, Function,
-    NativeWasmTypeInto, RuntimeError, WasmTypeList,
+    AsStoreMut, BackendStore, FromToNativeWasmType, Function, NativeWasmTypeInto, RuntimeError,
+    WasmTypeList, store::AsStoreRef,
 };
+use std::future::Future;
 use std::marker::PhantomData;
 use wasmer_types::RawValue;
 
@@ -78,6 +81,45 @@ macro_rules! impl_native_traits {
                 }
             }
 
+            /// 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)]
@@ -118,9 +160,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
 );
@@ -130,3 +178,9 @@ 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 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/utils/polyfill.rs b/lib/api/src/utils/polyfill.rs
index 8b54de444b..412068d45d 100644
--- a/lib/api/src/utils/polyfill.rs
+++ b/lib/api/src/utils/polyfill.rs
@@ -373,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:?}"))
     }
 }
 
diff --git a/lib/api/src/vm/impls.rs b/lib/api/src/vm/impls.rs
index 29877545d1..ea80315092 100644
--- a/lib/api/src/vm/impls.rs
+++ b/lib/api/src/vm/impls.rs
@@ -55,6 +55,11 @@ impl VMExternRef {
 impl VMExceptionRef {
     /// Converts the `VMExternRef` into a `RawValue`.
     pub fn into_raw(self) -> RawValue {
-        todo!()
+        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
index 01825f9ca5..131f848fbb 100644
--- a/lib/api/src/vm/mod.rs
+++ b/lib/api/src/vm/mod.rs
@@ -438,7 +438,6 @@ define_vm_like!(Trampoline);
 define_vm_like!(Function, Debug);
 define_vm_like!(Global, Debug);
 define_vm_like!(Tag, Debug);
-define_vm_like!(Exception, Debug);
 define_vm_like!(Memory, Debug, @From);
 define_vm_like!(SharedMemory);
 define_vm_like!(Table, Debug);
diff --git a/lib/api/tests/externals.rs b/lib/api/tests/externals.rs
index 6a063f8d83..f59611a8c8 100644
--- a/lib/api/tests/externals.rs
+++ b/lib/api/tests/externals.rs
@@ -157,7 +157,7 @@ fn table_set() -> Result<(), String> {
         let v = v.unwrap();
 
         let v = if let Value::ExternRef(Some(ext)) = v {
-            ext.downcast::<u32>(&mut store)
+            ext.downcast::<u32>(&store)
         } else {
             return Err("table.get does not match `ExternRef(Some(..))`!".into());
         };
@@ -175,7 +175,7 @@ fn table_set() -> Result<(), String> {
         let v = v.unwrap();
 
         let v = if let Value::ExternRef(Some(ext)) = v {
-            ext.downcast::<u32>(&mut store)
+            ext.downcast::<u32>(&store)
         } else {
             return Err("table.get does not match `ExternRef(Some(..))`!".into());
         };
@@ -194,7 +194,7 @@ fn table_set() -> Result<(), String> {
         let v = v.unwrap();
 
         let v = if let Value::ExternRef(Some(ext)) = v {
-            ext.downcast::<u32>(&mut store)
+            ext.downcast::<u32>(&store)
         } else {
             return Err("table.get does not match `ExternRef(Some(..))`!".into());
         };
@@ -250,7 +250,7 @@ fn table_copy() -> Result<(), String> {
 fn memory_new() -> Result<(), String> {
     let mut store = Store::default();
     let memory_type = MemoryType {
-        shared: if cfg!(feature = "wamr") { true } else { false },
+        shared: cfg!(feature = "wamr"),
         minimum: Pages(0),
         maximum: Some(Pages(10)),
     };
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 c79b6eed8c..4119e75d3e 100644
--- a/lib/api/tests/memory.rs
+++ b/lib/api/tests/memory.rs
@@ -1,11 +1,8 @@
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
-use wasmer::{
-    imports, Instance, Memory, MemoryAccessError, MemoryLocation, MemoryType, Module, Store,
-    WasmSlice,
-};
+use wasmer::{Instance, Memory, MemoryLocation, MemoryType, Module, Store, imports};
 
 #[test]
 #[cfg_attr(feature = "wamr", ignore = "wamr ignores import memories")]
@@ -44,9 +41,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;
+            }
         }
     });
 
@@ -108,12 +107,12 @@ fn test_wasm_slice_issue_5444() {
     let _inst = Instance::new(&mut store, &module, &imports).unwrap();
 
     let view = mem.view(&store);
-    let slice = WasmSlice::<u64>::new(&view, 1, 10).unwrap();
+    let slice = wasmer::WasmSlice::<u64>::new(&view, 1, 10).unwrap();
     let access = slice.access();
 
     assert!(matches!(
         access.err(),
-        Some(MemoryAccessError::UnalignedPointerRead)
+        Some(wasmer::MemoryAccessError::UnalignedPointerRead)
     ))
 }
 
diff --git a/lib/api/tests/module.rs b/lib/api/tests/module.rs
index cdfdd7d75e..83296c136e 100644
--- a/lib/api/tests/module.rs
+++ b/lib/api/tests/module.rs
@@ -195,11 +195,11 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
         "host" => {
             "host_func1" => Function::new_typed(&mut store, |p: u64| {
                 println!("host_func1: Found number {p}");
-                assert_eq!(p, u64::max_value());
+                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());
+                assert_eq!(p, u32::MAX);
             }),
             "host_func3" => Function::new_typed(&mut store, |p: i64| {
                 println!("host_func3: Found number {p}");
@@ -215,7 +215,7 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
             }),
             "host_func6" => Function::new_typed(&mut store, |p: u16| {
                 println!("host_func6: Found number {p}");
-                assert_eq!(p, u16::max_value());
+                assert_eq!(p, u16::MAX);
             }),
             "host_func7" => Function::new_typed(&mut store, |p: i8| {
                 println!("host_func7: Found number {p}");
@@ -223,7 +223,7 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
             }),
             "host_func8" => Function::new_typed(&mut store, |p: u8| {
                 println!("host_func8: Found number {p}");
-                assert_eq!(p, u8::max_value());
+                assert_eq!(p, u8::MAX);
             }),
         }
     };
diff --git a/lib/api/tests/reference_types.rs b/lib/api/tests/reference_types.rs
index b014e6b2f4..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::*;
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
index 12e52d9b28..d746a1a95f 100644
--- a/lib/api/tests/typed_functions.rs
+++ b/lib/api/tests/typed_functions.rs
@@ -96,7 +96,7 @@ fn non_typed_functions_and_closures_with_no_env_work() -> anyhow::Result<()> {
     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;
@@ -165,7 +165,7 @@ fn holochain_typed_function() -> anyhow::Result<()> {
 
     // Execute the WASM function 'sum'
     let sum: TypedFunction<(i32, i32), i32> =
-        instance.exports.get_function("sum")?.typed(&mut store)?;
+        instance.exports.get_function("sum")?.typed(&store)?;
     let result = sum.call(&mut store, 1, 2)?;
     assert_eq!(result, 6);
 
diff --git a/lib/backend-api/Cargo.toml b/lib/backend-api/Cargo.toml
index 93fe18e216..e83f1999fe 100644
--- a/lib/backend-api/Cargo.toml
+++ b/lib/backend-api/Cargo.toml
@@ -25,27 +25,26 @@ reqwest = { workspace = true, default-features = false, features = ["json"] }
 anyhow.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-serde_path_to_error = "0.1.14"
+serde_path_to_error.workspace = true
 time = { workspace = true, features = ["formatting", "parsing"] }
 tokio.workspace = true
 url = { workspace = true, features = ["serde"] }
-futures = "0.3"
-tracing.workspace = true
-cynic = { version = "3.7.2", features = ["http-reqwest"] }
-pin-project-lite = "0.2.10"
-harsh = "0.2.2"
-merge-streams = "0.1.2"
-
+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 = { version = "0.11.0", features = [
+graphql-ws-client = { workspace = true, features = [
 	"tungstenite",
 	"client-cynic",
 ], optional = true }
 tokio-tungstenite = { workspace = true, features = [
 	"rustls-tls-native-roots",
 ], optional = true }
-async-tungstenite = { version = "0.28.0", features = [
+async-tungstenite = { workspace = true, features = [
 	"tokio-runtime",
 	"tokio-rustls-native-certs",
 ], optional = true }
@@ -57,7 +56,7 @@ features = ["js"]
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt"] }
 base64.workspace = true
-uuid = { version = "1", features = ["v4"] }
+uuid = { workspace = true, features = ["v4"] }
 
 [features]
 
diff --git a/lib/backend-api/schema.graphql b/lib/backend-api/schema.graphql
index 2fd6fbec6f..2fd388e697 100644
--- a/lib/backend-api/schema.graphql
+++ b/lib/backend-api/schema.graphql
@@ -46,6 +46,7 @@ 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!
@@ -82,9 +83,10 @@ type User implements Node & PackageOwner & Owner {
   dashboardActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
   loginMethods: [LoginMethod!]!
   githubUser: SocialAuth
-  githubScopes: [String]!
-  githubRepositories: [GithubRepository]!
-  isPro: Boolean!
+  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]
@@ -92,7 +94,6 @@ type User implements Node & PackageOwner & Owner {
     """Optional time range filter."""
     timeRange: TimeRangeInput
   ): OwnerUsageSummary
-  webhooks: [Webhook]
 }
 
 """Setup for backwards compatibility with existing frontends."""
@@ -107,11 +108,11 @@ enum OwnerAction {
   PUBLISH_PACKAGE
 }
 
-"""An owner of a package."""
 interface Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  isPro: Boolean!
 }
 
 """
@@ -244,6 +245,7 @@ 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!
@@ -272,7 +274,6 @@ type Namespace implements Node & PackageOwner & Owner {
     timeRange: TimeRangeInput
   ): [UsageMetric]!
   domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
-  isPro: Boolean!
   billing: Billing
   currentUsage(
     """List of app IDs. Usage gets filtered for the specific apps."""
@@ -517,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
@@ -984,7 +986,8 @@ type DeployAppVersion implements Node {
   sourcePackage: Package!
   aggregateMetrics: AggregateMetrics!
   volumes: [AppVersionVolume]
-  gitSource: AutobuildRepository
+  gitSource: AutobuildRepository @deprecated(reason: "This field is deprecated and return null always.")
+  rolloutSource: Rollout
   favicon: URL
   screenshot(viewportSize: AppScreenshotViewportSize, appearance: AppScreenshotAppearance): URL
   isUploaded: Boolean!
@@ -1004,6 +1007,7 @@ type DeployApp implements Node & Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  isPro: Boolean!
   url: String!
   adminUrl: String!
   permalink: String!
@@ -1029,11 +1033,13 @@ type DeployApp implements Node & Owner {
   deleted: Boolean!
   favicon: URL
   screenshot(viewportSize: AppScreenshotViewportSize, appearance: AppScreenshotAppearance): URL
-  deployments(before: String, after: String, first: Int, last: Int): DeploymentConnection
+  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."""
@@ -1351,7 +1357,7 @@ enum StatusEnum {
   SUCCESS
   WORKING
   RUNNING
-  FAILURE
+  FAILED
   QUEUED
   TIMEOUT
   INTERNAL_ERROR
@@ -1360,31 +1366,108 @@ enum StatusEnum {
 
 type BuildConfiguration implements Node {
   setupDb: Boolean!
-  buildCmd: String!
-  installCmd: String!
-  canDeployWithoutRepo: Boolean!
+  startCmd: String
+  buildCmd: String
+  installCmd: String
   completionTimeInSeconds: Int!
   kind: BuildKind
-  repo: String!
 
   """The ID of the object"""
   id: ID!
-  name: String!
-  repoName: String!
-  repoNamespace: String!
+  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!
-  buildCmd: String!
-  installCmd: String!
-  canDeployWithoutRepo: 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!
@@ -1469,7 +1552,7 @@ type AppMail implements Node {
   id: ID!
 }
 
-union Kind = WordpressAppKind
+union Kind = WordpressAppKind | MCPServerAppKind
 
 type WordpressAppKind {
   adminUrl: String!
@@ -1509,6 +1592,18 @@ type WordPressTheme {
   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!
@@ -1548,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.
@@ -1711,6 +1826,7 @@ type AppTemplate implements Node {
   description: String!
   demoUrl: String!
   repoUrl: String!
+  rootDir: String
   branch: String
   category: AppTemplateCategory!
   isPublic: Boolean!
@@ -1724,6 +1840,7 @@ type AppTemplate implements Node {
   completionTimeInSeconds: Int!
   highlighted: Boolean!
   defaultImage: String
+  defaultRepositoryCloneName: String
   framework: String!
   templateFramework: TemplateFramework
   language: String!
@@ -2506,20 +2623,6 @@ type SocialAuth implements Node {
   username: String!
 }
 
-type GithubRepository {
-  url: String!
-  name: String!
-  namespace: String!
-}
-
-type Webhook implements Node {
-  url: String!
-  active: Boolean!
-
-  """The ID of the object"""
-  id: ID!
-}
-
 type Signature {
   id: ID!
   publicKey: PublicKey!
@@ -2533,136 +2636,43 @@ type StripeCustomer {
 
 type Billing {
   stripeCustomer: StripeCustomer!
-  payments: [PaymentIntent]!
+  payments: [PaymentIntent]! @deprecated(reason: "Use `payment_connection` instead")
   subscriptions: [WasmerSubscription]!
-  paymentMethods: [PaymentMethod]!
+  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!
-}
-
-"""An enumeration."""
-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
+  currency: String!
+  status: String!
+  invoicePdfUrl: String
 }
 
 type WasmerSubscription implements Node {
   """The datetime this object was created in stripe."""
   created: DateTime
 
-  """A description of this object."""
-  description: String
-
-  """
-  A date in the future at which the subscription will automatically get canceled.
-  """
+  """The ID of the object"""
+  id: ID!
   cancelAt: DateTime
-
-  """
-  If the subscription has been canceled with the ``at_period_end`` flag set to true, ``cancel_at_period_end`` on the subscription will be true. You can use this attribute to determine whether a subscription that has a status of active is scheduled to be canceled at the end of the current period.
-  """
-  cancelAtPeriodEnd: Boolean!
-
-  """
-  If the subscription has been canceled, the date of that cancellation. If the subscription was canceled with ``cancel_at_period_end``, canceled_at will still reflect the date of the initial cancellation request, not the end of the subscription period when the subscription is automatically moved to a canceled state.
-  """
   canceledAt: DateTime
-
-  """
-  End of the current period for which the subscription has been invoiced. At the end of this period, a new invoice will be created.
-  """
-  currentPeriodEnd: DateTime!
-
-  """
-  Start of the current period for which the subscription has been invoiced.
-  """
-  currentPeriodStart: DateTime!
-
-  """
-  Number of days a customer has to pay invoices generated by this subscription. This value will be `null` for subscriptions where `billing=charge_automatically`.
-  """
+  currentPeriodEnd: DateTime
+  currentPeriodStart: DateTime
   daysUntilDue: Int
-
-  """
-  If the subscription has ended (either because it was canceled or because the customer was switched to a subscription to a new plan), the date the subscription ended.
-  """
   endedAt: DateTime
-
-  """
-  Date when the subscription was first created. The date might differ from the created date due to backdating.
-  """
   startDate: DateTime
-
-  """The status of this subscription."""
-  status: DjstripeSubscriptionStatusChoices!
-
-  """If the subscription has a trial, the end of that trial."""
+  status: String
   trialEnd: DateTime
-
-  """If the subscription has a trial, the beginning of that trial."""
   trialStart: DateTime
-
-  """The ID of the object"""
-  id: ID!
-}
-
-"""An enumeration."""
-enum DjstripeSubscriptionStatusChoices {
-  """Active"""
-  ACTIVE
-
-  """Canceled"""
-  CANCELED
-
-  """Incomplete"""
-  INCOMPLETE
-
-  """Incomplete Expired"""
-  INCOMPLETE_EXPIRED
-
-  """Past due"""
-  PAST_DUE
-
-  """Trialing"""
-  TRIALING
-
-  """Unpaid"""
-  UNPAID
+  description: String
+  cancelAtPeriodEnd: Boolean
 }
 
 union PaymentMethod = CardPaymentMethod
@@ -2707,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
@@ -2875,6 +2925,36 @@ 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(active: Boolean, supportsVolumes: Boolean, supportsDatabases: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): AppRegionConnection!
@@ -2889,6 +2969,7 @@ 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
@@ -2908,6 +2989,8 @@ type Query {
     name: String!
   ): Boolean!
   wordpressDeploymentDefaults: WordpressDeploymentDefaults!
+  rollout(id: ID!): Rollout
+  githubRollout(id: ID!): GitHubRollout
   viewer: User
   getUser(username: String!): User
   getPasswordResetToken(token: String!): GetPasswordResetToken
@@ -3040,6 +3123,12 @@ enum DNSRecordsSortBy {
   OLDEST
 }
 
+type AutobuildDeploymentStatus {
+  buildId: UUID!
+  status: StatusEnum!
+  appVersion: DeployAppVersion
+}
+
 type TemplateFrameworkConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -3683,6 +3772,7 @@ type Mutation {
 
   """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
@@ -3699,6 +3789,13 @@ type Mutation {
   """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.")
 
@@ -3765,12 +3862,9 @@ type Mutation {
   mfa2EmailAuth(input: MFAEmailAuthInput!): MFAAuthResponse
   mfa2EmailGetToken(input: MFAGenerateEmailOTPInput!): MFAEmailGenerationResponse
   generateCheckoutUrl(input: GenerateCheckoutUrlInput!): GenerateCheckoutUrlPayload
-
-  """Add webhook to user"""
-  addWebhook(input: AddWebhookInput!): AddWebhookPayload
-
-  """Add webhook to user"""
-  removeWebhook(input: RemoveWebhookInput!): RemoveWebhookPayload
+  createCheckoutSession(input: CreateCheckoutSessionInput!): CreateCheckoutSessionPayload
+  cancelSubscription(input: CancelSubscriptionInput!): CancelSubscriptionPayload
+  renewCanceledSubscription(input: RenewCanceledSubscriptionInput!): RenewCanceledSubscriptionPayload
   publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
   publishPackage(input: PublishPackageInput!): PublishPackagePayload
   pushPackageRelease(input: PushPackageReleaseInput!): PushPackageReleasePayload
@@ -4438,31 +4532,56 @@ input DeleteAppDBInput {
   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]
+  deployedApps: [DeployApp] @deprecated(reason: "This field is not used anymore")
   clientMutationId: String
 }
 
 """The Build Configuration for a given repo"""
 type BuildConfig {
-  buildCmd: String!
-  installCmd: String!
+  startCmd: String
+  buildCmd: String
+  installCmd: String
   setupDb: Boolean!
   presetName: String!
   appName: String!
-  canDeployWithoutRepo: Boolean!
   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
 }
 
@@ -4472,7 +4591,7 @@ type AutobuildConfigForZipUploadPayload {
   buildConfig: BuildConfig
 
   """List of apps deployed with this repo."""
-  deployedApps: [DeployApp]
+  deployedApps: [DeployApp] @deprecated(reason: "This field is not used anymore")
   clientMutationId: String
 }
 
@@ -4486,12 +4605,19 @@ input AutobuildConfigForZipUploadInput {
 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
 }
 
@@ -4525,6 +4651,53 @@ input UpdateAutobuildConfigForAppInput {
   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!
@@ -4644,6 +4817,7 @@ input DeployViaAutobuildInput {
   owner: String
   buildCmd: String
   installCmd: String
+  startCmd: String
   enableDatabase: Boolean
   secrets: [SecretInput]
   extraData: AutobuildDeploymentExtraData
@@ -4659,6 +4833,12 @@ input DeployViaAutobuildInput {
   """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.
   """
@@ -4841,6 +5021,7 @@ input RegisterUserInput {
   acceptedTos: Boolean
   intent: String
   fingerprintVisitorId: String
+  enterProTrial: Boolean
   clientMutationId: String
 }
 
@@ -4856,6 +5037,8 @@ input SocialAuthJWTInput {
   register: Boolean = false
   registerIntent: String
   fingerprintVisitorId: String
+  enterProTrial: Boolean
+  response: JSONString
   clientMutationId: String
 }
 
@@ -5161,6 +5344,7 @@ type GenerateCheckoutUrlPayload {
 type StripeCheckout {
   url: String!
   expiresAt: DateTime!
+  clientSecret: String!
 }
 
 input GenerateCheckoutUrlInput {
@@ -5181,25 +5365,54 @@ input GenerateCheckoutUrlInput {
   clientMutationId: String
 }
 
-"""Add webhook to user"""
-type AddWebhookPayload {
-  webhook: Webhook!
+type CreateCheckoutSessionPayload {
+  clientSecret: String!
   clientMutationId: String
 }
 
-input AddWebhookInput {
-  url: 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
 }
 
-"""Add webhook to user"""
-type RemoveWebhookPayload {
-  success: Boolean!
+type CancelSubscriptionPayload {
+  ok: Boolean!
   clientMutationId: String
 }
 
-input RemoveWebhookInput {
-  id: ID!
+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
 }
 
diff --git a/lib/backend-api/src/client.rs b/lib/backend-api/src/client.rs
index f56e9553b8..8e28f7ef2d 100644
--- a/lib/backend-api/src/client.rs
+++ b/lib/backend-api/src/client.rs
@@ -2,8 +2,8 @@
 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;
@@ -13,7 +13,7 @@ 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>,
@@ -63,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
                     );
                 }
             }
@@ -201,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)
@@ -248,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 3b45e08c8c..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")
     }
diff --git a/lib/backend-api/src/global_id.rs b/lib/backend-api/src/global_id.rs
index 0e4f3e82bf..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;
diff --git a/lib/backend-api/src/query.rs b/lib/backend-api/src/query.rs
index ba72361111..aed555a017 100644
--- a/lib/backend-api/src/query.rs
+++ b/lib/backend-api/src/query.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashSet, time::Duration};
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use cynic::{MutationBuilder, QueryBuilder};
 use futures::StreamExt;
 use merge_streams::MergeStreams;
@@ -12,8 +12,8 @@ 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.
@@ -449,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}'"),
         },
     };
 
@@ -1841,7 +1841,7 @@ pub async fn generate_deploy_config_token_raw(
         .context("no token returned")
 }
 
-/// Generate an SSH token for accesing Edge over SSH or SFTP.
+/// 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.
@@ -1960,7 +1960,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)]
@@ -1997,7 +1997,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)]
@@ -2044,7 +2044,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)]
@@ -2099,8 +2099,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)
 }
@@ -2116,8 +2115,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)
 }
@@ -2131,8 +2129,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)
 }
@@ -2151,8 +2148,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
@@ -2170,7 +2166,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)
 }
 
@@ -2182,7 +2177,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
@@ -2235,7 +2229,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
index 2935546e58..016ede5270 100644
--- a/lib/backend-api/src/subscription.rs
+++ b/lib/backend-api/src/subscription.rs
@@ -1,9 +1,9 @@
 use crate::{
+    WasmerClient,
     types::{
         AutobuildDeploymentSubscription, AutobuildDeploymentSubscriptionVariables,
         PackageVersionReadySubscription, PackageVersionReadySubscriptionVariables, Uuid,
     },
-    WasmerClient,
 };
 use anyhow::Context;
 use async_tungstenite::tungstenite::client::IntoClientRequest;
diff --git a/lib/backend-api/src/types.rs b/lib/backend-api/src/types.rs
index e8741eb189..e84a715b87 100644
--- a/lib/backend-api/src/types.rs
+++ b/lib/backend-api/src/types.rs
@@ -303,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,
@@ -326,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)]
@@ -1324,7 +1328,7 @@ mod queries {
     pub enum StatusEnum {
         Success,
         Working,
-        Failure,
+        Failed,
         Queued,
         Timeout,
         InternalError,
@@ -1337,7 +1341,7 @@ mod queries {
             match self {
                 Self::Success => "success",
                 Self::Working => "working",
-                Self::Failure => "failure",
+                Self::Failed => "failed",
                 Self::Queued => "queued",
                 Self::Timeout => "timeout",
                 Self::InternalError => "internal_error",
@@ -1365,17 +1369,16 @@ mod queries {
     #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
     pub struct AutobuildConfigForZipUploadPayload {
         pub build_config: Option<BuildConfig>,
-        pub deployed_apps: Option<Vec<Option<DeployApp>>>,
     }
 
     #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
     pub struct BuildConfig {
-        pub build_cmd: String,
-        pub install_cmd: String,
+        pub 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 can_deploy_without_repo: bool,
         pub completion_time_in_seconds: i32,
         pub branch: Option<String>,
     }
diff --git a/lib/c-api/Cargo.toml b/lib/c-api/Cargo.toml
index c8628fdb76..86a5e22f40 100644
--- a/lib/c-api/Cargo.toml
+++ b/lib/c-api/Cargo.toml
@@ -44,8 +44,8 @@ enumset.workspace = true
 cfg-if.workspace = true
 libc.workspace = true
 thiserror.workspace = true
-typetag = { version = "0.1", optional = true }
-paste = "1.0"
+typetag = { workspace = true, optional = true }
+paste.workspace = true
 tokio = { workspace = true, features = [
 	"rt",
 	"rt-multi-thread",
@@ -57,13 +57,13 @@ 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", "sys-default", "cranelift", "compiler", "wasi", "middlewares"]
@@ -146,4 +146,7 @@ webc_runner = ["virtual-fs", "webc"]
 jit = ["compiler"]
 
 [build-dependencies]
-cbindgen = { version = "0.27", 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/build.rs b/lib/c-api/build.rs
index ee0ca5b001..315a70cef2 100644
--- a/lib/c-api/build.rs
+++ b/lib/c-api/build.rs
@@ -53,7 +53,7 @@ const MIDDLEWARES_FEATURE_AS_C_DEFINE: &str = "WASMER_MIDDLEWARES_ENABLED";
 const JSC_FEATURE_AS_C_DEFINE: &str = "WASMER_JSC_BACKEND";
 
 macro_rules! map_feature_as_c_define {
-    ($feature:expr, $c_define:ident, $accumulator:ident) => {
+    ($feature:expr_2021, $c_define:ident, $accumulator:ident) => {
         #[cfg(feature = $feature)]
         {
             use std::fmt::Write;
@@ -330,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 48c7342727..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 = "6.1.0"
-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/src/error.rs b/lib/c-api/src/error.rs
index 5925f78f53..769b670176 100644
--- a/lib/c-api/src/error.rs
+++ b/lib/c-api/src/error.rs
@@ -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 1b11792368..9beeebaa43 100644
--- a/lib/c-api/src/lib.rs
+++ b/lib/c-api/src/lib.rs
@@ -29,7 +29,7 @@
 // For the same reason, we also turn off the warning for camel_case types.
 #![allow(clippy::missing_safety_doc)]
 #![allow(non_camel_case_types)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![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/config/mod.rs b/lib/c-api/src/wasm_c_api/engine/config/mod.rs
index 33fc3dc49d..765b69a6c6 100644
--- a/lib/c-api/src/wasm_c_api/engine/config/mod.rs
+++ b/lib/c-api/src/wasm_c_api/engine/config/mod.rs
@@ -56,7 +56,7 @@ impl Default for wasmer_backend_config_kind_t {
                 Self::Sys(sys::wasmer_sys_engine_config_t::default())
             }
             #[cfg(feature = "v8")]
-            super::wasmer_backend_t::V8 => Self::V8(v8::wasmer_v8_engine_config_t::default()),
+            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::default())
@@ -121,7 +121,7 @@ pub(crate) struct wasmer_backend_config_t {
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[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);
 }
@@ -134,8 +134,8 @@ pub extern "C" fn wasm_config_set_target(config: &mut wasm_config_t, target: Box
 ///
 /// # Example
 ///
-/// See the documentation of the [`metering`] module.
-#[no_mangle]
+/// 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,
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
index 9faa61717f..29079eef0d 100644
--- a/lib/c-api/src/wasm_c_api/engine/config/sys.rs
+++ b/lib/c-api/src/wasm_c_api/engine/config/sys.rs
@@ -65,7 +65,7 @@ pub(crate) struct wasmer_sys_engine_config_t {
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[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;
diff --git a/lib/c-api/src/wasm_c_api/engine/mod.rs b/lib/c-api/src/wasm_c_api/engine/mod.rs
index d616381002..ed9c0eaf92 100644
--- a/lib/c-api/src/wasm_c_api/engine/mod.rs
+++ b/lib/c-api/src/wasm_c_api/engine/mod.rs
@@ -86,7 +86,7 @@ pub struct wasm_engine_t {
     pub(crate) inner: Engine,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[allow(unreachable_code)]
 pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
     Box::new(wasm_engine_t::default())
@@ -128,7 +128,7 @@ pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
 /// ```
 ///
 /// cbindgen:ignore
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_engine_delete(_engine: Option<Box<wasm_engine_t>>) {}
 
 /// Creates an engine with a particular configuration.
@@ -138,7 +138,7 @@ pub unsafe extern "C" fn wasm_engine_delete(_engine: Option<Box<wasm_engine_t>>)
 /// See [`wasm_config_new`].
 ///
 /// cbindgen:ignore
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_engine_new_with_config(
     config: Option<Box<wasm_config_t>>,
 ) -> Option<Box<wasm_engine_t>> {
@@ -208,7 +208,7 @@ pub struct wasm_config_t {
 /// ```
 ///
 /// cbindgen:ignore
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
     Box::<wasm_config_t>::default()
 }
@@ -240,7 +240,7 @@ pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
 /// # }
 /// ```
 /// cbindgen:ignore
-#[no_mangle]
+#[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.
@@ -274,7 +274,7 @@ pub extern "C" fn wasm_config_delete(_config: Option<Box<wasm_config_t>>) {}
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_config_set_backend(config: &mut wasm_config_t, engine: wasmer_backend_t) {
     config.backend = engine;
 }
@@ -286,7 +286,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_engine_new() {
         (assert_c! {
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 971c2c765e..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
@@ -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! {
@@ -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 da5b083bf5..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,7 +29,7 @@ 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>> {
@@ -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 459d5fdcf9..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, WasmTagType,
+    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;
@@ -89,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 {
@@ -178,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 4619f1c632..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) };
     }
 }
 
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 a3506925d8..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)]
@@ -77,7 +77,7 @@ pub struct wasm_limits_t {
 
 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/table.rs b/lib/c-api/src/wasm_c_api/types/table.rs
index 108f11c0de..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,5 +1,5 @@
 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};
 
@@ -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/value.rs b/lib/c-api/src/wasm_c_api/types/value.rs
index fc00f9fec3..5776a8c2cd 100644
--- a/lib/c-api/src/wasm_c_api/types/value.rs
+++ b/lib/c-api/src/wasm_c_api/types/value.rs
@@ -81,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 };
@@ -89,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 6366e39782..2acb212081 100644
--- a/lib/c-api/src/wasm_c_api/unstable/engine.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/engine.rs
@@ -44,7 +44,7 @@ use super::{
 /// #    .success();
 /// # }
 /// ```
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn wasm_config_set_features(
     config: &mut wasm_config_t,
     features: Box<wasmer_features_t>,
@@ -54,14 +54,14 @@ pub extern "C" fn wasm_config_set_features(
 
 /// 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 backend is available, i.e. part of this
 /// compiled library.
-#[no_mangle]
+#[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"),
@@ -85,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"
@@ -102,28 +104,32 @@ mod tests {
         })
         .success();
 
-        remove_var("COMPILER");
+        unsafe {
+            remove_var("COMPILER");
+        }
     }
 
     #[test]
     fn test_wasmer_is_backend_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"
-            },
-        );
+        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"
@@ -139,8 +145,10 @@ mod tests {
         })
         .success();
 
-        remove_var("CRANELIFT");
-        remove_var("LLVM");
-        remove_var("SINGLEPASS");
+        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 ba61250e9f..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,11 +200,12 @@ 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 => 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/module.rs b/lib/c-api/src/wasm_c_api/unstable/module.rs
index c5b3ddc6d0..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,7 +167,7 @@ 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>,
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 183e27499e..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
@@ -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 a678751ba4..920b70a7c5 100644
--- a/lib/c-api/src/wasm_c_api/value.rs
+++ b/lib/c-api/src/wasm_c_api/value.rs
@@ -131,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,
@@ -173,10 +173,12 @@ impl Drop for wasm_val_t {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasm_val_delete(val: *mut wasm_val_t) {
     if !val.is_null() {
-        std::ptr::drop_in_place(val);
+        unsafe {
+            std::ptr::drop_in_place(val);
+        }
     }
 }
 
@@ -215,7 +217,7 @@ impl TryFrom<&wasm_val_t> for Value {
             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_EXTERNREF => {
-                return Err("EXTERNREF not supported at this time")
+                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 6f1dd0b85b..107aa6f9f4 100644
--- a/lib/c-api/src/wasm_c_api/version.rs
+++ b/lib/c-api/src/wasm_c_api/version.rs
@@ -32,7 +32,7 @@ static VERSION_PATCH: LazyLock<u8> = LazyLock::new(|| {
 /// # 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 _
 }
@@ -71,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
 }
@@ -79,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
 }
@@ -87,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
 }
@@ -122,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 72243b7d2a..72ee5f47ce 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,23 @@ 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,
-    )?;
+    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 +264,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();
@@ -286,15 +291,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 +334,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();
 
@@ -360,10 +366,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 +380,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 +392,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 +425,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,7 +454,7 @@ 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) => {
@@ -518,7 +526,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 +535,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,9 +554,10 @@ 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());
 
@@ -557,15 +566,19 @@ unsafe fn wasi_get_imports_inner(
         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 +595,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 +649,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 +687,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 +725,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/wasmer-c-api-test-runner/Cargo.toml b/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
index e4e7259427..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 = "6.1.0"
-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/cache/Cargo.toml b/lib/cache/Cargo.toml
index 2dc69b3b80..ba1aa5b3f6 100644
--- a/lib/cache/Cargo.toml
+++ b/lib/cache/Cargo.toml
@@ -19,13 +19,13 @@ 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" }
+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 = "0.8.3"
+rand.workspace = true
 wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = ["sys", "cranelift"] }
 wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=6.1.0" }
 
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 dabec09f28..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 })
             }
@@ -103,7 +103,7 @@ impl Cache for FileSystemCache {
             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
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 dfc5c3de3d..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 = "=6.1.0", path = "../compiler", features = [
-	"compiler",
-] }
-wasmer-types = { version = "=6.1.0", path = "../types", features = ["detect-wasm-features"] }
-is-terminal = "0.4.7"
-colored = "2.0"
-anyhow.workspace = true
-# For the function names autosuggestion
-distance = "0.4"
-# For the inspect subcommand
-bytesize = "1.0"
-cfg-if.workspace = true
-# For debug feature
-fern = { version = "0.6", features = ["colored"], optional = true }
-log = { workspace = true, optional = true }
-target-lexicon = { workspace = true, features = ["std"] }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true }
-wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true }
-wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm", optional = true }
-clap = { version = "4.4.0", features = ["derive", "env"] }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true, default-features = false, features = [
-	"wasm",
-] }
-wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true, default-features = false, features = [
-	"wasm",
-] }
-wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm",  optional = true, default-features = false, features = [] }
-# NOTE: Must use different features for clap because the "color" feature does not
-# work on wasi, due to the anstream dependency not compiling.
-clap = { version = "4.4.0", default-features = false, features = [
-	"std",
-	"help",
-	"usage",
-	"error-context",
-	"suggestions",
-	"derive",
-	"env",
-] }
-
-[target.'cfg(target_os = "linux")'.dependencies]
-unix_mode = "0.1.3"
-
-[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 = []
-llvm = ["wasmer-compiler-llvm"]
-
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/cli-compiler/README.md b/lib/cli-compiler/README.md
deleted file mode 100644
index a4cba6cee9..0000000000
--- a/lib/cli-compiler/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# `wasmer-cli-compiler` 
-[![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
-
-This crate is the Wasmer Compiler only CLI.
-
-
-## Features
-
-The Compiler only Wasmer supports the following features:
-* `wasi` (default): support for [WASI].
-* `singlepass`: support for the [Singlepass compiler].
-
-[WASI]: https://github.com/wasmerio/wasmer/tree/main/lib/wasi/
-[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 c61d074130..0000000000
--- a/lib/cli-compiler/src/bin/wasmer_compiler.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use wasmer_compiler_cli::cli::wasmer_main;
-
-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 50c69649c5..0000000000
--- a/lib/cli-compiler/src/commands/compile.rs
+++ /dev/null
@@ -1,119 +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::target::{Architecture, CpuFeature, Target, Triple};
-use wasmer_types::{CompileError, MemoryIndex, MemoryStyle, TableIndex, TableStyle};
-
-#[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}");
-        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 81d562f027..0000000000
--- a/lib/cli-compiler/src/commands/config.rs
+++ /dev/null
@@ -1,106 +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 {key} environment variables",
-            ))?;
-
-        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{libdir} -lwasmer");
-
-        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 024d3791c2..0000000000
--- a/lib/cli-compiler/src/commands/validate.rs
+++ /dev/null
@@ -1,41 +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;
-use wasmer_types::target::{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 d1aa39a526..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 9d2c0bb372..0000000000
--- a/lib/cli-compiler/src/store.rs
+++ /dev/null
@@ -1,407 +0,0 @@
-//! Common module with common used structures across different
-//! commands.
-
-use crate::common::WasmFeatures;
-use anyhow::Result;
-use clap::Parser;
-#[cfg(doc)]
-use std::path::PathBuf;
-use std::string::ToString;
-#[allow(unused_imports)]
-use std::sync::Arc;
-use wasmer_compiler::{CompilerConfig, EngineBuilder, Features};
-use wasmer_types::target::{PointerWidth, Target};
-#[cfg(doc)]
-use wasmer_types::Type;
-use wasmer_types::{MemoryStyle, MemoryType, Pages, TableStyle, TableType};
-
-/// Minimul Subset of Tunable parameters for WebAssembly compilation.
-#[derive(Clone)]
-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,
-                };
-                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();
-                        }
-                    }
-
-                    fn asm_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        asm_memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.s", function_kind_to_filename(kind)));
-                        let mem_buf_slice = asm_memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                }
-
-                impl fmt::Debug for Callbacks {
-                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                        write!(f, "LLVMCallbacks")
-                    }
-                }
-
-                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
-                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
-                }
-                if self.enable_verifier {
-                    config.enable_verifier();
-                }
-                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 std::fmt::Display for CompilerType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Singlepass => "singlepass",
-                Self::Cranelift => "cranelift",
-                Self::LLVM => "llvm",
-                Self::Headless => "headless",
-            }
-        )
-    }
-}
-
-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 6bcd2e89c9..7c80d773b5 100644
--- a/lib/cli/Cargo.toml
+++ b/lib/cli/Cargo.toml
@@ -108,6 +108,8 @@ enable-serde = [
 	"wasmer-wasix/enable-serde",
 ]
 
+tokio-subscriber = ["dep:console-subscriber", "tokio/tracing"]
+
 [dependencies]
 # Repo-local dependencies.
 
@@ -152,6 +154,8 @@ wasmer-config = { version = "0.601.0", path = "../config" }
 
 shared-buffer = { workspace = true, optional = true }
 rkyv = { workspace = true, optional = true }
+
+# TODO: #5858
 fuser = { version = "0.14.0", optional = true }
 time01 = { package = "time", version = "0.1.45", optional = true }
 
@@ -159,62 +163,62 @@ time01 = { package = "time", version = "0.1.45", optional = true }
 # Third-party dependencies.
 
 http.workspace = true
-is-terminal = "0.4.7"
-colored = "2.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 = "4.0"
+dirs.workspace = true
+path-clean.workspace = true
 target-lexicon = { workspace = true, features = ["std"] }
 indexmap.workspace = true
-walkdir = "2.3.2"
-regex = "1.6.0"
+walkdir.workspace = true
+regex.workspace = true
 toml.workspace = true
 url.workspace = true
 libc.workspace = true
-parking_lot = "0.12"
-dialoguer = "0.11.0"
+parking_lot.workspace = true
+dialoguer.workspace = true
 hex.workspace = true
 flate2.workspace = true
-cargo_metadata = "0.15.2"
+cargo_metadata.workspace = true
 tar.workspace = true
 bytes.workspace = true
 thiserror.workspace = true
 log.workspace = true
 semver.workspace = true
-pathdiff = "0.2.1"
+pathdiff.workspace = true
 sha2.workspace = true
 object.workspace = true
-wasm-coredump-builder = { version = "0.1.11", optional = true }
+wasm-coredump-builder = { workspace = true, optional = true }
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = [
 	"env-filter",
 	"fmt",
 	"json",
+	"ansi"
 ] }
 async-trait = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 once_cell.workspace = true
-indicatif = "0.17.5"
-opener = "0.6.1"
-normpath = "=1.1.1"
+indicatif.workspace = true
+opener.workspace = true
+normpath.workspace = true
 hyper = { workspace = true, features = ["server"] }
 hyper-util = { workspace = true, features = ["tokio"] }
 http-body-util.workspace = true
-futures = "0.3.29"
-humantime = "2.1.0"
-interfaces = { version = "0.0.9", optional = true }
+futures.workspace = true
+humantime.workspace = true
+interfaces = { workspace = true, optional = true }
 
-uuid = { version = "1.3.0", features = ["v4"] }
+uuid = { workspace = true, features = ["v4"] }
 time = { workspace = true, features = ["macros"] }
 serde_yaml.workspace = true
 base64.workspace = true
-# FIXME: 7.2 is not compatible with Rust 1.84
-comfy-table = "=7.1.4"
-
+comfy-table.workspace = true
+git-version.workspace = true
 
 # Used by tuntap and connect
 futures-util.workspace = true
@@ -223,22 +227,24 @@ 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.4", default-features = false, features = ["deflate"] }
-console = "0.15.8"
-dotenvy = "0.15.7"
-lzma-rs = "0.3.0"
+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.4.0", features = ["derive", "env"] }
+clap = { workspace = true, default-features = true, features = ["derive", "env"] }
 [target.'cfg(target_family = "wasm")'.dependencies]
-clap = { version = "4.4.0", default-features = false, features = [
+clap = { workspace = true, default-features = false, features = [
 	"std",
 	"help",
 	"usage",
@@ -265,22 +271,22 @@ reqwest = { workspace = true, default-features = false, features = [
 
 
 [build-dependencies]
-chrono = { version = "0.4.38", 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"
+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"
diff --git a/lib/cli/build.rs b/lib/cli/build.rs
index b8e6525d56..28df3c148f 100644
--- a/lib/cli/build.rs
+++ b/lib/cli/build.rs
@@ -1,26 +1,6 @@
-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}");
diff --git a/lib/cli/src/backend.rs b/lib/cli/src/backend.rs
index ce3f449eca..214720427a 100644
--- a/lib/cli/src/backend.rs
+++ b/lib/cli/src/backend.rs
@@ -11,11 +11,11 @@ use std::string::ToString;
 use std::sync::Arc;
 use std::{path::PathBuf, str::FromStr};
 
-use anyhow::{bail, Result};
+use anyhow::{Context, Result, bail};
 #[cfg(feature = "sys")]
 use wasmer::sys::*;
 use wasmer::*;
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 #[cfg(feature = "compiler")]
 use wasmer_compiler::CompilerConfig;
@@ -188,25 +188,27 @@ pub struct RuntimeOptions {
     #[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>,
 
-    /// LLVM debug directory, where IR and object files will be written to.
-    ///
-    /// Only available for the LLVM compiler.
-    #[clap(long)]
-    llvm_debug_dir: Option<PathBuf>,
-
     /// Only available for the LLVM compiler. Enable the "pass-params" optimization, where the first (#0)
     /// global and the first (#0) memory passed between guest functions as explicit parameters.
+    #[cfg(feature = "llvm")]
     #[clap(long)]
     enable_pass_params_opt: bool,
 
     /// Only available for the LLVM compiler. Sets the number of threads used to compile the
     /// input module(s).
+    #[cfg(feature = "llvm")]
     #[clap(long)]
     llvm_num_threads: Option<NonZero<usize>>,
 
@@ -298,7 +300,7 @@ impl RuntimeOptions {
 
     pub fn get_engine(&self, target: &Target) -> Result<Engine> {
         let backends = self.get_available_backends()?;
-        let backend = backends.first().unwrap();
+        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)
@@ -338,7 +340,9 @@ impl RuntimeOptions {
                     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");
+                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
@@ -456,6 +460,12 @@ impl RuntimeOptions {
                         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)?));
+                }
 
                 Box::new(config)
             }
@@ -470,15 +480,17 @@ impl RuntimeOptions {
                         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)?));
+                }
                 Box::new(config)
             }
             #[cfg(feature = "llvm")]
             BackendType::LLVM => {
-                use std::{fmt, fs::File, io::Write};
-
-                use wasmer_compiler_llvm::{
-                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
-                };
+                use wasmer_compiler_llvm::LLVMCallbacks;
                 use wasmer_types::entity::EntityRef;
                 let mut config = LLVM::new();
 
@@ -490,109 +502,9 @@ impl RuntimeOptions {
                     config.num_threads(num_threads);
                 }
 
-                struct Callbacks {
-                    debug_dir: PathBuf,
-                }
-                impl Callbacks {
-                    fn new(debug_dir: PathBuf) -> Result<Self> {
-                        // Create the debug dir in case it doesn't exist
-                        std::fs::create_dir_all(&debug_dir)?;
-                        Ok(Self { debug_dir })
-                    }
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn types_to_signature(types: &[Type]) -> String {
-                    types
-                        .iter()
-                        .map(|ty| match ty {
-                            Type::I32 => "i".to_string(),
-                            Type::I64 => "I".to_string(),
-                            Type::F32 => "f".to_string(),
-                            Type::F64 => "F".to_string(),
-                            Type::V128 => "v".to_string(),
-                            Type::ExternRef => "e".to_string(),
-                            Type::FuncRef => "r".to_string(),
-                            Type::ExceptionRef => "x".to_string(),
-                        })
-                        .collect::<Vec<_>>()
-                        .join("")
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn function_kind_to_filename(kind: &CompiledKind) -> String {
-                    match kind {
-                        CompiledKind::Local(local_index) => {
-                            format!("function_{}", local_index.index())
-                        }
-                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
-                            "trampoline_call_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
-                            "trampoline_dynamic_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::Module => "module".into(),
-                    }
-                }
-                impl LLVMCallbacks for Callbacks {
-                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping pre optimized LLVM IR");
-                    }
-                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping post optimized LLVM IR");
-                    }
-                    fn obj_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.o", function_kind_to_filename(kind)));
-                        let mem_buf_slice = memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                    fn asm_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        asm_memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.s", function_kind_to_filename(kind)));
-                        let mem_buf_slice = asm_memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                }
-
-                impl fmt::Debug for Callbacks {
-                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                        write!(f, "LLVMCallbacks")
-                    }
-                }
-
-                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
-                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                if let Some(mut debug_dir) = self.compiler_debug_dir.clone() {
+                    debug_dir.push("llvm");
+                    config.callbacks(Some(LLVMCallbacks::new(debug_dir)?));
                 }
                 if self.enable_verifier {
                     config.enable_verifier();
@@ -608,10 +520,7 @@ impl RuntimeOptions {
             BackendType::V8 | BackendType::Wamr | BackendType::Wasmi => unreachable!(),
             #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm")))]
             compiler => {
-                bail!(
-                    "The `{}` compiler is not included in this binary.",
-                    compiler.to_string()
-                )
+                bail!("The `{compiler}` compiler is not included in this binary.")
             }
         };
 
@@ -685,6 +594,12 @@ impl BackendType {
                         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)?));
+                }
                 let engine = wasmer_compiler::EngineBuilder::new(config)
                     .set_features(Some(features.clone()))
                     .set_target(Some(target.clone()))
@@ -703,6 +618,12 @@ impl BackendType {
                         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)?));
+                }
                 let engine = wasmer_compiler::EngineBuilder::new(config)
                     .set_features(Some(features.clone()))
                     .set_target(Some(target.clone()))
@@ -712,118 +633,14 @@ impl BackendType {
             }
             #[cfg(feature = "llvm")]
             Self::LLVM => {
-                use std::{fmt, fs::File, io::Write};
-
-                use wasmer_compiler_llvm::{
-                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
-                };
+                use wasmer_compiler_llvm::LLVMCallbacks;
                 use wasmer_types::entity::EntityRef;
 
                 let mut config = wasmer_compiler_llvm::LLVM::new();
 
-                struct Callbacks {
-                    debug_dir: PathBuf,
-                }
-                impl Callbacks {
-                    fn new(debug_dir: PathBuf) -> Result<Self> {
-                        // Create the debug dir in case it doesn't exist
-                        std::fs::create_dir_all(&debug_dir)?;
-                        Ok(Self { debug_dir })
-                    }
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn types_to_signature(types: &[Type]) -> String {
-                    types
-                        .iter()
-                        .map(|ty| match ty {
-                            Type::I32 => "i".to_string(),
-                            Type::I64 => "I".to_string(),
-                            Type::F32 => "f".to_string(),
-                            Type::F64 => "F".to_string(),
-                            Type::V128 => "v".to_string(),
-                            Type::ExternRef => "e".to_string(),
-                            Type::FuncRef => "r".to_string(),
-                            Type::ExceptionRef => "x".to_string(),
-                        })
-                        .collect::<Vec<_>>()
-                        .join("")
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn function_kind_to_filename(kind: &CompiledKind) -> String {
-                    match kind {
-                        CompiledKind::Local(local_index) => {
-                            format!("function_{}", local_index.index())
-                        }
-                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
-                            "trampoline_call_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
-                            "trampoline_dynamic_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::Module => "module".into(),
-                    }
-                }
-                impl LLVMCallbacks for Callbacks {
-                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping pre optimized LLVM IR");
-                    }
-                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping post optimized LLVM IR");
-                    }
-                    fn obj_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.o", function_kind_to_filename(kind)));
-                        let mem_buf_slice = memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                    fn asm_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        asm_memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.s", function_kind_to_filename(kind)));
-                        let mem_buf_slice = asm_memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                }
-
-                impl fmt::Debug for Callbacks {
-                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                        write!(f, "LLVMCallbacks")
-                    }
-                }
-
-                if let Some(ref llvm_debug_dir) = runtime_opts.llvm_debug_dir {
-                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                if let Some(mut debug_dir) = runtime_opts.compiler_debug_dir.clone() {
+                    debug_dir.push("llvm");
+                    config.callbacks(Some(LLVMCallbacks::new(debug_dir)?));
                 }
                 if runtime_opts.enable_verifier {
                     config.enable_verifier();
diff --git a/lib/cli/src/c_gen/staticlib_header.rs b/lib/cli/src/c_gen/staticlib_header.rs
index 3767c6b6c1..3f690822c4 100644
--- a/lib/cli/src/c_gen/staticlib_header.rs
+++ b/lib/cli/src/c_gen/staticlib_header.rs
@@ -3,7 +3,7 @@
 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 {
diff --git a/lib/cli/src/commands/add.rs b/lib/cli/src/commands/add.rs
index 83b232143b..d06d12c5ec 100644
--- a/lib/cli/src/commands/add.rs
+++ b/lib/cli/src/commands/add.rs
@@ -4,8 +4,8 @@ use anyhow::{Context, Error};
 use clap::Parser;
 use std::process::{Command, Stdio};
 use wasmer_backend_api::{
-    types::{Bindings, ProgrammingLanguage},
     WasmerClient,
+    types::{Bindings, ProgrammingLanguage},
 };
 use wasmer_config::package::NamedPackageIdent;
 
@@ -58,7 +58,7 @@ impl AsyncCliCommand for CmdAdd {
             )
         })?;
 
-        anyhow::ensure!(status.success(), "Command failed: {:?}", cmd);
+        anyhow::ensure!(status.success(), "Command failed: {cmd:?}");
 
         Ok(())
     }
@@ -173,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() {
@@ -193,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 701fd3a516..e57b13b21a 100644
--- a/lib/cli/src/commands/app/create.rs
+++ b/lib/cli/src/commands/app/create.rs
@@ -10,13 +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 indexmap::IndexMap;
-use is_terminal::IsTerminal;
+use path_clean::PathClean;
+use std::io::IsTerminal as _;
 use wasmer_backend_api::{
-    types::{AppTemplate, TemplateLanguage},
     WasmerClient,
+    types::{AppTemplate, TemplateLanguage},
 };
 use wasmer_config::{app::AppConfigV1, package::PackageSource};
 
@@ -234,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 {
@@ -271,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);
         };
@@ -401,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;
@@ -483,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;
@@ -512,17 +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_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 {
@@ -599,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(
@@ -621,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();
@@ -638,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)
@@ -655,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() {
diff --git a/lib/cli/src/commands/app/delete.rs b/lib/cli/src/commands/app/delete.rs
index 6ae4ca19db..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};
diff --git a/lib/cli/src/commands/app/deploy.rs b/lib/cli/src/commands/app/deploy.rs
index 7e5095a46c..c43f510898 100644
--- a/lib/cli/src/commands/app/deploy.rs
+++ b/lib/cli/src/commands/app/deploy.rs
@@ -1,32 +1,32 @@
-use super::{util::login_user, AsyncCliCommand};
+use super::{AsyncCliCommand, util::login_user};
 use crate::{
     commands::{
-        app::create::{minimal_app_config, write_app_config, CmdAppCreate},
-        package::publish::PackagePublish,
         PublishWait,
+        app::create::{CmdAppCreate, minimal_app_config, write_app_config},
+        package::publish::PackagePublish,
     },
     config::WasmerEnv,
     opts::ItemFormatOpts,
-    utils::{load_package_manifest, DEFAULT_PACKAGE_MANIFEST_FILE},
+    utils::{DEFAULT_PACKAGE_MANIFEST_FILE, load_package_manifest},
 };
 use anyhow::Context;
 use bytesize::ByteSize;
 use colored::Colorize;
-use dialoguer::{theme::ColorfulTheme, Confirm};
+use dialoguer::{Confirm, theme::ColorfulTheme};
 use indexmap::IndexMap;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 use std::io::Write;
 use std::{path::Path, path::PathBuf, str::FromStr, time::Duration};
 use wasmer_backend_api::{
-    types::{AutoBuildDeployAppLogKind, DeployApp, DeployAppVersion},
     WasmerClient,
+    types::{AutoBuildDeployAppLogKind, DeployApp, DeployAppVersion},
 };
 use wasmer_config::{
     app::AppConfigV1,
     package::{PackageIdent, PackageSource},
 };
 use wasmer_sdk::app::deploy_remote_build::{
-    deploy_app_remote, DeployRemoteEvent, DeployRemoteOpts,
+    DeployRemoteEvent, DeployRemoteOpts, deploy_app_remote,
 };
 
 static EDGE_HEADER_APP_VERSION_ID: http::HeaderName =
@@ -603,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()
+                );
             }
         }
 
@@ -629,7 +632,10 @@ impl AsyncCliCommand for CmdAppDeploy {
         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_backend_api::query::current_user_with_namespaces(&client, None).await?;
@@ -759,7 +765,7 @@ impl AsyncCliCommand for CmdAppDeploy {
         }
 
         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() {
@@ -903,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()),
@@ -915,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()),
diff --git a/lib/cli/src/commands/app/logs.rs b/lib/cli/src/commands/app/logs.rs
index 4ecd47275d..9a487d5497 100644
--- a/lib/cli/src/commands/app/logs.rs
+++ b/lib/cli/src/commands/app/logs.rs
@@ -4,7 +4,7 @@ use crate::utils::timestamp::parse_timestamp_or_relative_time_negative_offset;
 use colored::Colorize;
 use comfy_table::{Cell, Table};
 use futures::StreamExt;
-use time::{format_description::well_known::Rfc3339, OffsetDateTime};
+use time::{OffsetDateTime, format_description::well_known::Rfc3339};
 use wasmer_backend_api::types::{Log, LogStream};
 
 use crate::{config::WasmerEnv, opts::ListFormatOpts, utils::render::CliRender};
diff --git a/lib/cli/src/commands/app/regions/list.rs b/lib/cli/src/commands/app/regions/list.rs
index 9828d24abb..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)]
diff --git a/lib/cli/src/commands/app/secrets/create.rs b/lib/cli/src/commands/app/secrets/create.rs
index f0570562aa..0719184f3c 100644
--- a/lib/cli/src/commands/app/secrets/create.rs
+++ b/lib/cli/src/commands/app/secrets/create.rs
@@ -1,12 +1,12 @@
 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},
@@ -102,7 +102,10 @@ impl CmdAppSecretsCreate {
         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()
+                        );
                     }
                 }
             }
diff --git a/lib/cli/src/commands/app/secrets/delete.rs b/lib/cli/src/commands/app/secrets/delete.rs
index 093b243905..62333115a5 100644
--- a/lib/cli/src/commands/app/secrets/delete.rs
+++ b/lib/cli/src/commands/app/secrets/delete.rs
@@ -1,10 +1,10 @@
 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_backend_api::WasmerClient;
 
@@ -150,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 ba14eb6148..7ead78ae2b 100644
--- a/lib/cli/src/commands/app/secrets/update.rs
+++ b/lib/cli/src/commands/app/secrets/update.rs
@@ -1,12 +1,12 @@
 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},
@@ -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()
+                        );
                     }
                 }
             }
diff --git a/lib/cli/src/commands/app/secrets/utils/mod.rs b/lib/cli/src/commands/app/secrets/utils/mod.rs
index e6e329851a..b5c3d7c45c 100644
--- a/lib/cli/src/commands/app/secrets/utils/mod.rs
+++ b/lib/cli/src/commands/app/secrets/utils/mod.rs
@@ -6,9 +6,9 @@ use std::{
     path::{Path, PathBuf},
     str::FromStr,
 };
-use wasmer_backend_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 {
@@ -130,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
             }
diff --git a/lib/cli/src/commands/app/util.rs b/lib/cli/src/commands/app/util.rs
index dfc22e6a0b..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 dialoguer::{Confirm, theme::ColorfulTheme};
 use wasmer_backend_api::{
+    WasmerClient,
     global_id::{GlobalId, NodeKind},
     types::DeployApp,
-    WasmerClient,
 };
 use wasmer_config::app::AppConfigV1;
 
@@ -340,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.")
         }
@@ -368,8 +370,8 @@ pub fn get_app_config_from_dir_opt(
     Ok(Some((config, app_config_path)))
 }
 
-pub fn get_app_config_from_current_dir_opt(
-) -> Result<Option<(AppConfigV1, std::path::PathBuf)>, anyhow::Error> {
+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)
 }
diff --git a/lib/cli/src/commands/app/version/get.rs b/lib/cli/src/commands/app/version/get.rs
index 66494724e9..3ca7172fc9 100644
--- a/lib/cli/src/commands/app/version/get.rs
+++ b/lib/cli/src/commands/app/version/get.rs
@@ -1,7 +1,7 @@
 use anyhow::Context;
 
 use crate::{
-    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentOpts},
     config::WasmerEnv,
     opts::ItemFormatOpts,
     utils::render::ItemFormat,
diff --git a/lib/cli/src/commands/app/version/list.rs b/lib/cli/src/commands/app/version/list.rs
index 491a79540f..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_backend_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
 
 use crate::{
-    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    commands::{AsyncCliCommand, app::util::AppIdentOpts},
     config::WasmerEnv,
     opts::ListFormatOpts,
 };
diff --git a/lib/cli/src/commands/app/volumes/credentials/mod.rs b/lib/cli/src/commands/app/volumes/credentials/mod.rs
index 38d70515f5..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,
 };
 
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 e2d041c64f..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,
 };
diff --git a/lib/cli/src/commands/auth/login/auth_server.rs b/lib/cli/src/commands/auth/login/auth_server.rs
index 4b2060ac68..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;
 
diff --git a/lib/cli/src/commands/auth/login/mod.rs b/lib/cli/src/commands/auth/login/mod.rs
index 5388964947..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_backend_api::{types::Nonce, WasmerClient};
+use wasmer_backend_api::{WasmerClient, types::Nonce};
 
 #[derive(Debug, Clone)]
 enum AuthorizationState {
@@ -256,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.",
@@ -352,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);
 
@@ -379,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 ffbb79789a..b8934a6483 100644
--- a/lib/cli/src/commands/auth/logout.rs
+++ b/lib/cli/src/commands/auth/logout.rs
@@ -1,9 +1,9 @@
 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 _;
 
 /// Log out from Wasmer
 #[derive(Debug, Clone, clap::Parser)]
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/compile.rs b/lib/cli/src/commands/compile.rs
index 4c2cc45389..c1d347d529 100644
--- a/lib/cli/src/commands/compile.rs
+++ b/lib/cli/src/commands/compile.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
 use wasmer::{
     sys::{engine::NativeEngineExt, *},
@@ -81,11 +81,19 @@ 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: {}", engine.deterministic_id());
diff --git a/lib/cli/src/commands/config.rs b/lib/cli/src/commands/config.rs
index 035d6bf887..643f8fd2ca 100644
--- a/lib/cli/src/commands/config.rs
+++ b/lib/cli/src/commands/config.rs
@@ -1,6 +1,6 @@
 use crate::{
-    config::{UpdateRegistry, WasmerConfig, WasmerEnv},
     VERSION,
+    config::{UpdateRegistry, WasmerConfig, WasmerEnv},
 };
 use anyhow::{Context, Result};
 use clap::Parser;
@@ -272,14 +272,13 @@ impl GetOrSet {
                     StorableConfigField::RegistryUrl(s) => {
                         config.registry.set_current_registry(&s.url).await;
                         let current_registry = config.registry.get_current_registry();
-                        if let Ok(client) = env.client() {
-                            if let Some(u) =
+                        if let Ok(client) = env.client()
+                            && let Some(u) =
                                 wasmer_backend_api::query::current_user(&client).await?
-                            {
-                                println!(
+                        {
+                            println!(
                                 "Successfully logged into registry {current_registry:?} as user {u:?}"
                             );
-                            }
                         }
                     }
                     StorableConfigField::RegistryToken(t) => {
diff --git a/lib/cli/src/commands/create_exe.rs b/lib/cli/src/commands/create_exe.rs
index d4fba44fe1..52599337b0 100644
--- a/lib/cli/src/commands/create_exe.rs
+++ b/lib/cli/src/commands/create_exe.rs
@@ -4,10 +4,10 @@ use self::utils::normalize_atom_name;
 use super::CliCommand;
 use crate::{
     backend::RuntimeOptions,
-    common::{normalize_path, HashAlgorithm},
+    common::{HashAlgorithm, normalize_path},
     config::WasmerEnv,
 };
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use clap::Parser;
 use object::ObjectSection;
 use serde::{Deserialize, Serialize};
@@ -49,8 +49,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>,
 
@@ -635,7 +635,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()
             );
         }
 
@@ -692,7 +693,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"
+                    ));
                 }
             }
         }
@@ -1304,7 +1307,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())));
@@ -1388,10 +1395,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
@@ -1450,7 +1456,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())));
@@ -1508,9 +1518,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();
@@ -1564,10 +1574,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};")?;
@@ -1576,9 +1586,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})"
                     )
                 })?;
             writeln!(
@@ -1617,7 +1627,7 @@ 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::target::{CpuFeature, Target};
 
@@ -1647,20 +1657,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()
+                ));
             }
         }
 
@@ -1767,10 +1777,10 @@ pub(super) mod utils {
             return None;
         }
 
-        if let Architecture::Aarch64(_) = target.architecture {
-            if !(filename.contains("aarch64") || filename.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 {
@@ -1783,22 +1793,22 @@ pub(super) mod utils {
             }
         }
 
-        if let OperatingSystem::Windows = target.operating_system {
-            if !filename.contains("windows") {
-                return None;
-            }
+        if let OperatingSystem::Windows = target.operating_system
+            && !filename.contains("windows")
+        {
+            return None;
         }
 
-        if let OperatingSystem::Darwin = target.operating_system {
-            if !(filename.contains("apple") || filename.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 !filename.contains("linux") {
-                return None;
-            }
+        if let OperatingSystem::Linux = target.operating_system
+            && !filename.contains("linux")
+        {
+            return None;
         }
 
         Some(true)
@@ -1851,7 +1861,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:#?})"
+            )
         })
     }
 
@@ -1879,7 +1891,7 @@ pub(super) mod utils {
         };
         let os = match target_triple.operating_system {
             OperatingSystem::Linux => "linux".into(),
-            OperatingSystem::Darwin => "macos".into(),
+            OperatingSystem::Darwin(_) => "macos".into(),
             OperatingSystem::Windows => "windows".into(),
             v => v.to_string(),
         };
@@ -1948,14 +1960,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() {
@@ -1965,16 +1981,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);
@@ -2008,7 +2020,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)
         }
@@ -2143,7 +2158,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>,
@@ -2290,7 +2305,7 @@ mod http_fetch {
     ) -> Result<std::path::PathBuf, anyhow::Error> {
         let filename = browser_download_url
             .split('/')
-            .last()
+            .next_back()
             .unwrap_or("output")
             .to_string();
 
diff --git a/lib/cli/src/commands/create_obj.rs b/lib/cli/src/commands/create_obj.rs
index a50d823d9e..a7586a4fde 100644
--- a/lib/cli/src/commands/create_obj.rs
+++ b/lib/cli/src/commands/create_obj.rs
@@ -21,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>,
 
diff --git a/lib/cli/src/commands/gen_c_header.rs b/lib/cli/src/commands/gen_c_header.rs
index 2a6bcec2ce..38763da7fe 100644
--- a/lib/cli/src/commands/gen_c_header.rs
+++ b/lib/cli/src/commands/gen_c_header.rs
@@ -4,11 +4,11 @@ use anyhow::{Context, Error};
 use bytes::Bytes;
 use clap::Parser;
 use wasmer_compiler::{
-    object::ObjectMetadataBuilder, types::symbols::ModuleMetadataSymbolRegistry, Artifact,
+    Artifact, object::ObjectMetadataBuilder, types::symbols::ModuleMetadataSymbolRegistry,
 };
 use wasmer_package::{package::WasmerPackageError, utils::from_bytes};
 use wasmer_types::target::{CpuFeature, Triple};
-use webc::{compat::SharedBytes, Container, ContainerError, DetectError};
+use webc::{Container, ContainerError, DetectError, compat::SharedBytes};
 
 use crate::backend::RuntimeOptions;
 
@@ -82,7 +82,9 @@ impl GenCHeader {
         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`.");
+            anyhow::bail!(
+                "Cannot use this engine to generate c-headers! Please, use one of `cranelift`, `llvm` or `singlepass`."
+            );
         }
         let engine = engine.into_sys();
 
diff --git a/lib/cli/src/commands/gen_completions.rs b/lib/cli/src/commands/gen_completions.rs
index e3b64794d7..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)]
diff --git a/lib/cli/src/commands/init.rs b/lib/cli/src/commands/init.rs
index 26b416bb3a..33fc7d771a 100644
--- a/lib/cli/src/commands/init.rs
+++ b/lib/cli/src/commands/init.rs
@@ -556,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(),
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 31225350be..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;
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/mount/fs.rs b/lib/cli/src/commands/journal/mount/fs.rs
index 556797965a..c2f75955bc 100644
--- a/lib/cli/src/commands/journal/mount/fs.rs
+++ b/lib/cli/src/commands/journal/mount/fs.rs
@@ -7,7 +7,7 @@ use std::{
     hash::{Hash, Hasher},
     io,
     path::{Path, PathBuf},
-    sync::{atomic::AtomicU32, Arc, Mutex},
+    sync::{Arc, Mutex, atomic::AtomicU32},
     time::Duration,
 };
 
@@ -19,19 +19,19 @@ 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,
+    mem_fs::{self, OffloadBackingStore},
 };
 use wasmer_wasix::{
+    VIRTUAL_ROOT_FD,
     fs::WasiFdSeed,
     journal::{
-        copy_journal, ArchivedJournalEntry, ArchivedJournalEntryFileDescriptorWriteV1, Journal,
-        JournalEntry, JournalEntryFileDescriptorWriteV1, LogFileJournal, LogWriteResult,
-        ReadableJournal, WritableJournal,
+        ArchivedJournalEntry, ArchivedJournalEntryFileDescriptorWriteV1, Journal, JournalEntry,
+        JournalEntryFileDescriptorWriteV1, LogFileJournal, LogWriteResult, ReadableJournal,
+        WritableJournal, copy_journal,
     },
     types::Oflags,
     wasmer_wasix_types::wasi,
-    VIRTUAL_ROOT_FD,
 };
 
 #[derive(Debug)]
diff --git a/lib/cli/src/commands/mod.rs b/lib/cli/src/commands/mod.rs
index c77840f5c2..03c4e3408f 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")]
@@ -53,6 +54,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 +77,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 => {}
@@ -233,14 +235,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();
 
@@ -262,16 +311,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();
@@ -471,14 +518,41 @@ 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 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") {
         runtimes.push("singlepass");
diff --git a/lib/cli/src/commands/package/build.rs b/lib/cli/src/commands/package/build.rs
index 16590d208d..c0f14e6fe2 100644
--- a/lib/cli/src/commands/package/build.rs
+++ b/lib/cli/src/commands/package/build.rs
@@ -1,7 +1,7 @@
 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;
diff --git a/lib/cli/src/commands/package/common/mod.rs b/lib/cli/src/commands/package/common/mod.rs
index ef5a32e302..3221529f0f 100644
--- a/lib/cli/src/commands/package/common/mod.rs
+++ b/lib/cli/src/commands/package/common/mod.rs
@@ -219,7 +219,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.")
         }
     }
diff --git a/lib/cli/src/commands/package/common/wait.rs b/lib/cli/src/commands/package/common/wait.rs
index 0aef557cfa..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::StreamExt;
-use wasmer_backend_api::{types::PackageVersionState, WasmerClient};
+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)]
diff --git a/lib/cli/src/commands/package/download.rs b/lib/cli/src/commands/package/download.rs
index 54888fa407..2feca66827 100644
--- a/lib/cli/src/commands/package/download.rs
+++ b/lib/cli/src/commands/package/download.rs
@@ -1,7 +1,7 @@
 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};
@@ -16,8 +16,8 @@ use crate::config::WasmerEnv;
 ///   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/`.
+///   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)]
@@ -190,7 +190,7 @@ impl PackageDownload {
                 (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 = {
diff --git a/lib/cli/src/commands/package/publish.rs b/lib/cli/src/commands/package/publish.rs
index df34b4751d..bafeee76e2 100644
--- a/lib/cli/src/commands/package/publish.rs
+++ b/lib/cli/src/commands/package/publish.rs
@@ -1,16 +1,16 @@
 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_backend_api::WasmerClient;
 use wasmer_config::package::{Manifest, PackageIdent};
diff --git a/lib/cli/src/commands/package/push.rs b/lib/cli/src/commands/package/push.rs
index af4318af59..831e60cb56 100644
--- a/lib/cli/src/commands/package/push.rs
+++ b/lib/cli/src/commands/package/push.rs
@@ -5,7 +5,7 @@ use crate::{
 };
 use anyhow::Context;
 use colored::Colorize;
-use is_terminal::IsTerminal;
+use std::io::IsTerminal as _;
 use std::path::{Path, PathBuf};
 use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::{Manifest, PackageHash};
@@ -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 {
@@ -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)
@@ -153,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..
@@ -184,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 ce4ad0d81f..fb2c44d436 100644
--- a/lib/cli/src/commands/package/tag.rs
+++ b/lib/cli/src/commands/package/tag.rs
@@ -1,14 +1,14 @@
 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,
@@ -268,7 +268,9 @@ impl PackageTag {
             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('-'))
@@ -326,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 {
@@ -367,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 {
@@ -466,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()
diff --git a/lib/cli/src/commands/package/unpack.rs b/lib/cli/src/commands/package/unpack.rs
index 08e579d4bb..25d58b429a 100644
--- a/lib/cli/src/commands/package/unpack.rs
+++ b/lib/cli/src/commands/package/unpack.rs
@@ -1,7 +1,7 @@
 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;
 
diff --git a/lib/cli/src/commands/run/capabilities/mod.rs b/lib/cli/src/commands/run/capabilities/mod.rs
index ada750bd57..43e3c36bc9 100644
--- a/lib/cli/src/commands/run/capabilities/mod.rs
+++ b/lib/cli/src/commands/run/capabilities/mod.rs
@@ -1,6 +1,6 @@
 use crate::config::WasmerEnv;
 
-use super::PackageSource;
+use super::CliPackageSource;
 use anyhow::anyhow;
 use sha2::{Digest, Sha256};
 use std::{
@@ -25,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()?
@@ -36,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()
@@ -61,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()?;
 
@@ -82,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_{}_{}",
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 e92a857731..881681a896 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,40 +19,40 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-use anyhow::{anyhow, bail, Context, Error};
+use anyhow::{Context, Error, anyhow, bail};
 use clap::{Parser, ValueEnum};
 use futures::future::BoxFuture;
 use indicatif::{MultiProgress, ProgressBar};
-use is_terminal::IsTerminal as _;
 use once_cell::sync::Lazy;
 use tempfile::NamedTempFile;
 use url::Url;
 #[cfg(feature = "sys")]
 use wasmer::sys::NativeEngineExt;
 use wasmer::{
-    AsStoreMut, DeserializeError, Engine, Function, Imports, Instance, Module, Store, Type,
-    TypedFunction, Value,
+    AsStoreMut, DeserializeError, Engine, Function, Imports, Instance, Module, RuntimeError, Store,
+    Type, TypedFunction, Value,
 };
 
-use wasmer_types::{target::Target, Features};
+use wasmer_types::{Features, target::Target};
 
 #[cfg(feature = "compiler")]
 use wasmer_compiler::ArtifactBuild;
-use wasmer_config::package::PackageSource as PackageSpecifier;
+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::{
+    Runtime, SpawnError, WasiError,
     bin_factory::{BinaryPackage, BinaryPackageCommand},
     journal::CompactingLogFileJournal,
     runners::{
+        MappedCommand, MappedDirectory, Runner,
         dcgi::{DcgiInstanceFactory, DcgiRunner},
         dproxy::DProxyRunner,
         wasi::{RuntimeOrEngine, WasiRunner},
         wcgi::{self, AbortHandle, NoOpWcgiCallbacks, WcgiRunner},
-        MappedCommand, MappedDirectory, Runner,
     },
     runtime::{
         module_cache::{CacheError, HashedModuleData},
@@ -57,16 +60,19 @@ use wasmer_wasix::{
         resolver::QueryError,
         task_manager::VirtualTaskManagerExt,
     },
-    Runtime, SpawnError, WasiError,
 };
-use webc::metadata::Manifest;
 use webc::Container;
+use webc::metadata::Manifest;
 
 use crate::{
     backend::RuntimeOptions, commands::run::wasi::Wasi, common::HashAlgorithm, config::WasmerEnv,
     error::PrettyError, logging::Output,
 };
 
+use self::{
+    package_source::CliPackageSource, runtime::MonitoringRuntime, target::ExecutableTarget,
+};
+
 const TICK: Duration = Duration::from_millis(250);
 
 /// The unstable `wasmer run` subcommand.
@@ -93,8 +99,8 @@ pub struct Run {
     #[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
@@ -139,7 +145,7 @@ impl Run {
 
         // Try to detect WebAssembly features before selecting a backend
         tracing::info!("Input source: {:?}", self.input);
-        if let PackageSource::File(path) = &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
@@ -158,7 +164,9 @@ impl Run {
                             );
                             wasm_bytes = Some(bytes);
                         } else {
-                            tracing::info!("File does not have valid WebAssembly magic number, will try to run it anyway");
+                            tracing::info!(
+                                "File does not have valid WebAssembly magic number, will try to run it anyway"
+                            );
                             // Still provide the bytes so the engine can attempt to run it
                             wasm_bytes = Some(bytes);
                         }
@@ -184,7 +192,7 @@ impl Run {
             }
             None => {
                 // No WebAssembly file available for analysis, check if we have a webc package
-                if let PackageSource::Package(ref pkg_source) = &self.input {
+                if let CliPackageSource::Package(pkg_source) = &self.input {
                     tracing::info!("Checking package for WebAssembly features: {}", pkg_source);
                     self.rt.get_engine(&Target::default())?
                 } else {
@@ -218,7 +226,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;
 
@@ -244,56 +256,61 @@ impl Run {
                 } => self.execute_wasm(&path, module, module_hash, runtime.clone()),
                 ExecutableTarget::Package(pkg) => {
                     // Check if we should update the engine based on the WebC package features
-                    if let Some(cmd) = pkg.get_entrypoint_command() {
-                        if let Some(features) = cmd.wasm_features() {
-                            // Get the right engine for these features
-                            let backends = self.rt.get_available_backends()?;
-                            let available_engines = backends
-                                .iter()
-                                .map(|b| b.to_string())
-                                .collect::<Vec<_>>()
-                                .join(", ");
-
-                            let filtered_backends = RuntimeOptions::filter_backends_by_features(
-                                backends.clone(),
-                                &features,
+                    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(),
-                            );
-
-                            if !filtered_backends.is_empty() {
-                                let engine_id = filtered_backends[0].to_string();
-
-                                // Get a new engine that's compatible with the required features
-                                if let Ok(new_engine) = filtered_backends[0].get_engine(
-                                    &Target::default(),
-                                    &features,
-                                    &self.rt,
-                                ) {
-                                    tracing::info!(
-                                        "The command '{}' requires to run the Wasm module with the features {:?}. The backends available are {}. Choosing {}.",
-                                        cmd.name(),
-                                        features,
-                                        available_engines,
-                                        engine_id
-                                    );
-                                    // Create a new runtime with the updated engine
-                                    let new_runtime = self.wasi.prepare_runtime(
-                                        new_engine,
+                                &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,
-                                        &capabilities::get_capability_cache_path(
-                                            &self.env,
-                                            &self.input,
-                                        )?,
-                                        tokio::runtime::Builder::new_multi_thread()
-                                            .enable_all()
-                                            .build()?,
-                                        preferred_webc_version,
+                                        &self.input,
                                     )?;
-
-                                    let new_runtime =
-                                        Arc::new(MonitoringRuntime::new(new_runtime, pb.clone()));
-                                    return self.execute_webc(&pkg, new_runtime);
-                                }
+                                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);
                             }
                         }
                     }
@@ -303,10 +320,10 @@ impl Run {
         };
 
         // 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 {
@@ -371,7 +388,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();
@@ -505,18 +523,24 @@ impl Run {
             }
         };
 
-        let return_values = invoke_function(&instance, &mut store, entry_function, &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(
@@ -527,8 +551,7 @@ impl Run {
 
         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()?;
 
         runner
             .with_args(&self.args)
@@ -537,10 +560,16 @@ 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);
         }
@@ -609,44 +638,6 @@ impl Run {
             }
         }
     }
-
-    /// 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!(not(target_os = "linux")) {
-            bail!("binfmt_misc is only available on linux.");
-        }
-
-        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 rt = RuntimeOptions::default();
-        Ok(Run {
-            env: WasmerEnv::default(),
-            rt,
-            wasi: Wasi::for_binfmt_interpreter()?,
-            wcgi: WcgiOptions::default(),
-            stack_size: None,
-            entrypoint: Some(original_executable.to_string()),
-            invoke: None,
-            coredump_on_trap: None,
-            input: PackageSource::infer(executable)?,
-            args: args.to_vec(),
-            hash_algorithm: None,
-        })
-    }
 }
 
 fn invoke_function(
@@ -654,16 +645,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
@@ -675,9 +664,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> {
@@ -692,204 +679,6 @@ fn parse_value(s: &str, ty: wasmer_types::Type) -> Result<Value, Error> {
     Ok(value)
 }
 
-/// 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)?;
-                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 = 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() {
@@ -1011,218 +800,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()
-    }
-
-    #[cfg(feature = "journal")]
-    fn read_only_journals<'a>(
-        &'a self,
-    ) -> Box<dyn Iterator<Item = Arc<wasmer_wasix::journal::DynReadableJournal>> + 'a> {
-        self.runtime.read_only_journals()
-    }
-
-    #[cfg(feature = "journal")]
-    fn writable_journals<'a>(
-        &'a self,
-    ) -> Box<dyn Iterator<Item = Arc<wasmer_wasix::journal::DynJournal>> + 'a> {
-        self.runtime.writable_journals()
-    }
-
-    #[cfg(feature = "journal")]
-    fn active_journal(&self) -> Option<&'_ wasmer_wasix::journal::DynJournal> {
-        self.runtime.active_journal()
-    }
-
-    fn load_hashed_module(
-        &self,
-        module: HashedModuleData,
-        engine: Option<&Engine>,
-    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
-        let hash = *module.hash();
-        let fut = self.runtime.load_hashed_module(module, engine);
-        Box::pin(compile_with_progress(fut, hash, None))
-    }
-
-    fn load_hashed_module_sync(
-        &self,
-        wasm: HashedModuleData,
-        engine: Option<&Engine>,
-    ) -> Result<Module, wasmer_wasix::SpawnError> {
-        let hash = *wasm.hash();
-        compile_with_progress_sync(
-            || self.runtime.load_hashed_module_sync(wasm, engine),
-            &hash,
-            None,
-        )
-    }
-
-    fn load_command_module(
-        &self,
-        cmd: &BinaryPackageCommand,
-    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
-        let fut = self.runtime.load_command_module(cmd);
-
-        Box::pin(compile_with_progress(
-            fut,
-            *cmd.hash(),
-            Some(cmd.name().to_owned()),
-        ))
-    }
-
-    fn load_command_module_sync(
-        &self,
-        cmd: &wasmer_wasix::bin_factory::BinaryPackageCommand,
-    ) -> Result<Module, wasmer_wasix::SpawnError> {
-        compile_with_progress_sync(
-            || self.runtime.load_command_module_sync(cmd),
-            cmd.hash(),
-            Some(cmd.name()),
-        )
-    }
-}
-
-async fn compile_with_progress<'a, F, T>(fut: F, hash: ModuleHash, name: Option<String>) -> T
-where
-    F: std::future::Future<Output = T> + Send + 'a,
-    T: Send + 'static,
-{
-    let mut pb = new_progressbar_compile(&hash, name.as_deref());
-    let res = fut.await;
-    pb.finish_and_clear();
-    res
-}
-
-fn compile_with_progress_sync<F, T>(f: F, hash: &ModuleHash, name: Option<&str>) -> T
-where
-    F: FnOnce() -> T,
-{
-    let mut pb = new_progressbar_compile(hash, name);
-    let res = f();
-    pb.finish_and_clear();
-    res
-}
-
-fn new_progressbar_compile(hash: &ModuleHash, name: Option<&str>) -> ProgressBar {
-    // Only show a spinner if we're running in a TTY
-    if std::io::stderr().is_terminal() {
-        let msg = if let Some(name) = name {
-            format!("Compiling WebAssembly module for command '{name}' ({hash})...")
-        } else {
-            format!("Compiling WebAssembly module {hash}...")
-        };
-        let pb = ProgressBar::new_spinner().with_message(msg);
-        pb.enable_steady_tick(Duration::from_millis(100));
-        pb
-    } else {
-        ProgressBar::hidden()
-    }
-}
-
-#[derive(Debug)]
-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..d0e712b6e0
--- /dev/null
+++ b/lib/cli/src/commands/run/runtime.rs
@@ -0,0 +1,285 @@
+//! 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::{
+        module_cache::HashedModuleData,
+        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 load_hashed_module(
+        &self,
+        module: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        if self.quiet_mode {
+            Box::pin(self.runtime.load_hashed_module(module, engine))
+        } else {
+            let hash = *module.hash();
+            let fut = self.runtime.load_hashed_module(module, engine);
+            Box::pin(compile_with_progress(
+                &self.progress,
+                fut,
+                hash,
+                None,
+                self.quiet_mode,
+            ))
+        }
+    }
+
+    fn load_hashed_module_sync(
+        &self,
+        wasm: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> Result<Module, wasmer_wasix::SpawnError> {
+        if self.quiet_mode {
+            self.runtime.load_hashed_module_sync(wasm, engine)
+        } else {
+            let hash = *wasm.hash();
+            compile_with_progress_sync(
+                &self.progress,
+                move || self.runtime.load_hashed_module_sync(wasm, engine),
+                &hash,
+                None,
+            )
+        }
+    }
+
+    fn load_command_module(
+        &self,
+        cmd: &BinaryPackageCommand,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        if self.quiet_mode {
+            self.runtime.load_command_module(cmd)
+        } else {
+            let fut = self.runtime.load_command_module(cmd);
+
+            Box::pin(compile_with_progress(
+                &self.progress,
+                fut,
+                *cmd.hash(),
+                Some(cmd.name().to_owned()),
+                self.quiet_mode,
+            ))
+        }
+    }
+
+    fn load_command_module_sync(
+        &self,
+        cmd: &wasmer_wasix::bin_factory::BinaryPackageCommand,
+    ) -> Result<Module, wasmer_wasix::SpawnError> {
+        if self.quiet_mode {
+            self.runtime.load_command_module_sync(cmd)
+        } else {
+            compile_with_progress_sync(
+                &self.progress,
+                || self.runtime.load_command_module_sync(cmd),
+                cmd.hash(),
+                Some(cmd.name()),
+            )
+        }
+    }
+}
+
+async fn compile_with_progress<'a, F, T>(
+    bar: &ProgressBar,
+    fut: F,
+    hash: ModuleHash,
+    name: Option<String>,
+    quiet_mode: bool,
+) -> T
+where
+    F: std::future::Future<Output = T> + Send + 'a,
+    T: Send + 'static,
+{
+    if quiet_mode {
+        fut.await
+    } else {
+        let should_clear = bar.is_finished() || bar.is_hidden();
+        show_compile_progress(bar, &hash, name.as_deref());
+        let res = fut.await;
+        if should_clear {
+            bar.finish_and_clear();
+        }
+
+        res
+    }
+}
+
+fn compile_with_progress_sync<F, T>(
+    bar: &ProgressBar,
+    f: F,
+    hash: &ModuleHash,
+    name: Option<&str>,
+) -> T
+where
+    F: FnOnce() -> T,
+{
+    let should_clear = bar.is_finished() || bar.is_hidden();
+    show_compile_progress(bar, hash, name);
+    let res = f();
+    if should_clear {
+        bar.finish_and_clear();
+    }
+    res
+}
+
+fn show_compile_progress(bar: &ProgressBar, hash: &ModuleHash, name: Option<&str>) {
+    // Only show a spinner if we're running in a TTY
+    let hash = hash.to_string();
+    let hash = &hash[0..8];
+    let msg = if let Some(name) = name {
+        format!("Compiling WebAssembly module for command '{name}' ({hash})...")
+    } else {
+        format!("Compiling WebAssembly module {hash}...")
+    };
+
+    bar.set_message(msg);
+    bar.enable_steady_tick(Duration::from_millis(100));
+
+    if bar.is_finished() || bar.is_hidden() {
+        bar.reset();
+    }
+}
+
+#[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 f5a8b7604a..e324e668e2 100644
--- a/lib/cli/src/commands/run/wasi.rs
+++ b/lib/cli/src/commands/run/wasi.rs
@@ -2,11 +2,11 @@ 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 tokio::runtime::Handle;
@@ -19,12 +19,14 @@ 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, DynReadableJournal},
-    os::{tty_sys::SysTty, TtyBridge},
+    os::{TtyBridge, tty_sys::SysTty},
     rewind_ext,
     runners::MAPPED_CURRENT_DIR_DEFAULT_PATH,
     runners::{MappedCommand, MappedDirectory},
@@ -35,14 +37,12 @@ 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::{
@@ -51,8 +51,8 @@ use crate::{
 };
 
 use super::{
+    CliPackageSource, ExecutableTarget,
     capabilities::{self, PkgCapabilityCache},
-    ExecutableTarget, PackageSource,
 };
 
 const WAPM_SOURCE_CACHE_TIMEOUT: Duration = Duration::from_secs(10 * 60);
@@ -60,7 +60,7 @@ 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
+    /// WASI pre-opened directories
     #[clap(long = "dir", name = "DIR", group = "wasi")]
     pub(crate) pre_opened_directories: Vec<PathBuf>,
 
@@ -72,6 +72,11 @@ pub struct Wasi {
     )]
     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",
@@ -294,7 +299,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())
@@ -314,7 +319,9 @@ impl Wasi {
             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");
+                        bail!(
+                            "Cannot pre-open the current directory twice: --dir=. must only be specified once"
+                        );
                     }
                     have_current_dir = true;
 
@@ -370,7 +377,9 @@ impl Wasi {
 
                 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: '--mapdir=?:.' / '--dir=.' must only be specified once"
+                        );
                     }
                     have_current_dir = true;
 
@@ -390,7 +399,7 @@ impl Wasi {
             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()));
+                    Arc::new(PassthruFileSystem::new_arc(default_fs_backing()));
                 for MappedDirectory { host, guest } in self.mapped_dirs.clone() {
                     let host = if !host.is_absolute() {
                         Path::new("/").join(host)
@@ -401,16 +410,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(".", "/")?
             }
         };
 
@@ -479,9 +495,7 @@ impl Wasi {
         Ok(Vec::new())
     }
 
-    pub fn build_mapped_directories(
-        &self,
-    ) -> Result<(bool, bool, Vec<MappedDirectory>), anyhow::Error> {
+    pub fn build_mapped_directories(&self) -> Result<(bool, Vec<MappedDirectory>), anyhow::Error> {
         let mut mapped_dirs = Vec::new();
 
         // Process the --dirs flag and merge it with --mapdir.
@@ -489,7 +503,9 @@ impl Wasi {
         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");
+                    bail!(
+                        "Cannot pre-open the current directory twice: --dir=. must only be specified once"
+                    );
                 }
                 have_current_dir = true;
 
@@ -545,7 +561,9 @@ impl Wasi {
 
             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: '--mapdir=?:.' / '--dir=.' must only be specified once"
+                    );
                 }
                 have_current_dir = true;
 
@@ -562,9 +580,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> {
@@ -617,7 +633,7 @@ 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>,
     {
@@ -726,7 +742,7 @@ impl Wasi {
         &self,
         env: &WasmerEnv,
         client: Arc<dyn HttpClient + Send + Sync>,
-    ) -> Result<impl PackageLoader> {
+    ) -> Result<BuiltinPackageLoader> {
         let checkout_dir = env.cache_dir().join("checkouts");
         let tokens = tokens_by_authority(env)?;
 
@@ -743,7 +759,7 @@ impl Wasi {
         env: &WasmerEnv,
         client: Arc<dyn HttpClient + Send + Sync>,
         preferred_webc_version: webc::Version,
-    ) -> Result<impl Source + Send> {
+    ) -> Result<MultiSource> {
         let mut source = MultiSource::default();
 
         // Note: This should be first so our "preloaded" sources get a chance to
@@ -802,17 +818,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
@@ -829,10 +845,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 d128b950ba..ff5f95889d 100644
--- a/lib/cli/src/commands/ssh.rs
+++ b/lib/cli/src/commands/ssh.rs
@@ -1,9 +1,9 @@
 //! Edge SSH command.
 
 use anyhow::Context;
-use wasmer_backend_api::{types::DeployApp, WasmerClient};
+use wasmer_backend_api::{WasmerClient, types::DeployApp};
 
-use super::{app::AppIdentArgOpts, AsyncCliCommand};
+use super::{AsyncCliCommand, app::AppIdentArgOpts};
 use crate::{config::WasmerEnv, edge_config::LoadedEdgeConfig};
 
 /// Start a remote SSH session.
@@ -126,7 +126,7 @@ 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}"))
         }
     }
 }
diff --git a/lib/cli/src/commands/validate.rs b/lib/cli/src/commands/validate.rs
index 450ae50bd4..4485a14074 100644
--- a/lib/cli/src/commands/validate.rs
+++ b/lib/cli/src/commands/validate.rs
@@ -1,8 +1,8 @@
 use std::path::PathBuf;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
-use wasmer::{is_wasm, Module};
+use wasmer::{Module, is_wasm};
 use wasmer_types::target::Target;
 
 use crate::backend::RuntimeOptions;
diff --git a/lib/cli/src/commands/wasmer_create_exe_main.c b/lib/cli/src/commands/wasmer_create_exe_main.c
index c4c60fcea6..ec728bcd4e 100644
--- a/lib/cli/src/commands/wasmer_create_exe_main.c
+++ b/lib/cli/src/commands/wasmer_create_exe_main.c
@@ -124,7 +124,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 52c97cab3c..0b8c33dbfa 100644
--- a/lib/cli/src/commands/wast.rs
+++ b/lib/cli/src/commands/wast.rs
@@ -4,8 +4,8 @@ use std::path::PathBuf;
 use anyhow::{Context, Result};
 use clap::Parser;
 use wasmer::{
-    sys::{engine::NativeEngineExt, Target},
     Store,
+    sys::{Target, engine::NativeEngineExt},
 };
 use wasmer_wast::Wast as WastSpectest;
 
diff --git a/lib/cli/src/common.rs b/lib/cli/src/common.rs
index f65d4eaeca..247b38019f 100644
--- a/lib/cli/src/common.rs
+++ b/lib/cli/src/common.rs
@@ -41,20 +41,15 @@ pub(crate) fn normalize_path(s: &str) -> String {
 }
 
 /// Hashing algorithm to be used for the module info
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, ValueEnum)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, ValueEnum, Default)]
 pub enum HashAlgorithm {
     /// Sha256
+    #[default]
     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 {
diff --git a/lib/cli/src/config/env.rs b/lib/cli/src/config/env.rs
index 6a4fe4c6be..99728b8ef2 100644
--- a/lib/cli/src/config/env.rs
+++ b/lib/cli/src/config/env.rs
@@ -22,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>,
 
@@ -150,8 +149,7 @@ impl WasmerEnv {
             Ok(Self::APP_DOMAIN_DEV.to_string())
         } else {
             anyhow::bail!(
-                "could not determine app domain for backend url '{}': unknown backend",
-                domain
+                "could not determine app domain for backend url '{domain}': unknown backend"
             );
         }
     }
@@ -179,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)
diff --git a/lib/cli/src/config/mod.rs b/lib/cli/src/config/mod.rs
index 0a9822e183..55824d1def 100644
--- a/lib/cli/src/config/mod.rs
+++ b/lib/cli/src/config/mod.rs
@@ -81,6 +81,7 @@ impl Default for MultiRegistry {
     }
 }
 
+#[allow(unused)]
 #[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
 pub struct Registry {
     pub url: String,
@@ -181,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 7d5aa5f903..fc12c7e914 100644
--- a/lib/cli/src/edge_config.rs
+++ b/lib/cli/src/edge_config.rs
@@ -4,7 +4,7 @@ use std::{
     time::Duration,
 };
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 
@@ -35,10 +35,7 @@ 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)?;
@@ -137,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
+                );
             }
         }
     }
diff --git a/lib/cli/src/lib.rs b/lib/cli/src/lib.rs
index 1b2961e6c0..cdf22c4975 100644
--- a/lib/cli/src/lib.rs
+++ b/lib/cli/src/lib.rs
@@ -13,7 +13,7 @@
 )]
 // 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;
diff --git a/lib/cli/src/logging.rs b/lib/cli/src/logging.rs
index 1f4c7a0097..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"];
 
@@ -32,9 +32,16 @@ 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_ansi(self.should_emit_colors())
@@ -49,18 +56,24 @@ impl Output {
             }
         };
 
-        let filter_layer = self.log_filter();
+        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 {
diff --git a/lib/cli/src/utils/mod.rs b/lib/cli/src/utils/mod.rs
index c418b8e179..f918cea6b3 100644
--- a/lib/cli/src/utils/mod.rs
+++ b/lib/cli/src/utils/mod.rs
@@ -6,14 +6,9 @@ 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 wasmer_wasix::runners::MappedDirectory;
 
 fn retrieve_alias_pathbuf(alias: &str, real_dir: &str) -> Result<MappedDirectory> {
@@ -95,7 +90,7 @@ pub fn load_package_manifest(
                     "Could not read package manifest at '{}'",
                     file_path.display()
                 )
-            })
+            });
         }
     };
 
@@ -110,78 +105,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.
@@ -249,46 +172,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/prompts.rs b/lib/cli/src/utils/prompts.rs
index 2e2209f2ad..f5754ce6df 100644
--- a/lib/cli/src/utils/prompts.rs
+++ b/lib/cli/src/utils/prompts.rs
@@ -1,6 +1,6 @@
 use anyhow::Context;
 use colored::Colorize;
-use dialoguer::{theme::ColorfulTheme, Select};
+use dialoguer::{Select, theme::ColorfulTheme};
 use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::NamedPackageIdent;
 
diff --git a/lib/cli/src/utils/timestamp.rs b/lib/cli/src/utils/timestamp.rs
index 61b61f187f..d9e4b109ed 100644
--- a/lib/cli/src/utils/timestamp.rs
+++ b/lib/cli/src/utils/timestamp.rs
@@ -1,6 +1,6 @@
 use time::{
-    format_description::well_known::{Rfc2822, Rfc3339},
     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.
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 44ab1886ed..3132b1a2b0 100644
--- a/lib/compiler-cranelift/Cargo.toml
+++ b/lib/compiler-cranelift/Cargo.toml
@@ -14,20 +14,22 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = [
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", default-features = false, features = [
 	"translator",
 	"compiler",
-], default-features = false }
+] }
 wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = [
 	"std",
 ] }
-cranelift-entity = { version = "=0.110.2", default-features = false }
-cranelift-codegen = { version = "=0.110.2", default-features = false, features = [
+
+cranelift-entity = { workspace = true }
+cranelift-codegen = { workspace = true, features = [
 	"x86",
 	"arm64",
 	"riscv64",
 ] }
-cranelift-frontend = { version = "=0.110.2", default-features = false }
+cranelift-frontend = { workspace = true }
+
 itertools.workspace = true
 tracing.workspace = true
 hashbrown = { workspace = true, optional = true }
@@ -35,10 +37,10 @@ rayon = { workspace = true, optional = true }
 more-asserts.workspace = true
 gimli = { workspace = true, optional = true }
 smallvec.workspace = true
-target-lexicon = { workspace = true, default-features = false }
+target-lexicon = { workspace = true }
 
 [dev-dependencies]
-cranelift-codegen = { version = "=0.110.2", features = ["all-arch"] }
+cranelift-codegen = { workspace = true, features = ["all-arch"] }
 
 [badges]
 maintenance = { status = "actively-developed" }
diff --git a/lib/compiler-cranelift/build.rs b/lib/compiler-cranelift/build.rs
deleted file mode 100644
index 69eb555dbe..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/compiler.rs b/lib/compiler-cranelift/src/compiler.rs
index 6acb6efec4..21e6892af6 100644
--- a/lib/compiler-cranelift/src/compiler.rs
+++ b/lib/compiler-cranelift/src/compiler.rs
@@ -3,21 +3,23 @@
 #[cfg(feature = "unwind")]
 use crate::dwarf::WriterRelocate;
 
+#[cfg(feature = "unwind")]
+use crate::translator::CraneliftUnwindInfo;
 use crate::{
     address_map::get_function_address_map,
     config::Cranelift,
-    func_environ::{get_function_name, FuncEnvironment},
+    func_environ::{FuncEnvironment, get_function_name},
     trampoline::{
-        make_trampoline_dynamic_function, make_trampoline_function_call, FunctionBuilderContext,
+        FunctionBuilderContext, make_trampoline_dynamic_function, make_trampoline_function_call,
     },
     translator::{
-        compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
-        signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
+        FuncTranslator, compiled_function_unwind_info, irlibcall_to_libcall,
+        irreloc_to_relocationkind, signature_to_cranelift_ir,
     },
 };
 use cranelift_codegen::{
-    ir::{self, ExternalName, UserFuncName},
     Context, FinalizedMachReloc, FinalizedRelocTarget, MachTrap,
+    ir::{self, ExternalName, UserFuncName},
 };
 
 #[cfg(feature = "unwind")]
@@ -27,21 +29,25 @@ use gimli::write::{Address, EhFrame, FrameTable, Writer};
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use std::sync::Arc;
 
+#[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},
-        section::SectionIndex,
-        unwind::CompiledFunctionUnwindInfo,
     },
-    Compiler, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader, ModuleMiddleware,
-    ModuleMiddlewareChain, ModuleTranslationState,
 };
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::target::{CallingConvention, Target};
+#[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::{
     CompileError, FunctionIndex, LocalFunctionIndex, ModuleInfo, SignatureIndex, TrapCode,
     TrapInformation,
@@ -112,128 +118,9 @@ impl CraneliftCompiler {
             }
         };
 
-        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);
-                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),
-                );
-
-                func_translator.translate(
-                    module_translation_state,
-                    &mut reader,
-                    &mut context.func,
-                    &mut func_env,
-                    i,
-                )?;
-
-                let mut code_buf: Vec<u8> = Vec::new();
-                context
-                    .compile_and_emit(&*isa, &mut code_buf, &mut Default::default())
-                    .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
-
-                let result = context.compiled_code().unwrap();
-                let func_relocs = result
-                    .buffer
-                    .relocs()
-                    .into_iter()
-                    .map(|r| mach_reloc_to_reloc(module, r))
-                    .collect::<Vec<_>>();
-
-                let traps = result
-                    .buffer
-                    .traps()
-                    .into_iter()
-                    .map(mach_trap_to_trap)
-                    .collect::<Vec<_>>();
-
-                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))
-                        } else {
-                            (None, None)
-                        }
-                    }
-                    #[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();
-        #[cfg(feature = "rayon")]
-        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
-            .iter()
-            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
-            .par_iter()
-            .map_init(FuncTranslator::new, |func_translator, (i, input)| {
+        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(
@@ -243,7 +130,7 @@ impl CraneliftCompiler {
                     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];
@@ -276,17 +163,42 @@ impl CraneliftCompiler {
                     *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)),
+                        context.func.display().to_string().as_bytes(),
+                    );
+                }
+
                 let mut code_buf: Vec<u8> = Vec::new();
-                context
-                    .compile_and_emit(&*isa, &mut code_buf, &mut Default::default())
+                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)),
+                        &code_buf,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::Local(*i, compile_info.module.get_function_name(func_index)),
+                        target.triple().architecture,
+                        &code_buf,
+                    )?;
+                }
 
-                let result = context.compiled_code().unwrap();
                 let func_relocs = result
                     .buffer
                     .relocs()
                     .iter()
-                    .map(|r| mach_reloc_to_reloc(module, r))
+                    .map(|r| mach_reloc_to_reloc(module, &func_name_map, r))
                     .collect::<Vec<_>>();
 
                 let traps = result
@@ -337,11 +249,37 @@ impl CraneliftCompiler {
                     },
                     fde,
                 ))
+            };
+
+        #[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"))]
+        #[cfg_attr(not(feature = "unwind"), allow(unused_variables))]
+        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .into_iter()
+            .map(|(i, input)| compile_function(&mut func_translator, (&i, input)))
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .unzip();
+        #[cfg(feature = "rayon")]
+        #[cfg_attr(not(feature = "unwind"), allow(unused_variables))]
+        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .par_iter()
+            .map_init(FuncTranslator::new, |func_translator, &(i, input)| {
+                compile_function(func_translator, (&i, input))
             })
             .collect::<Result<Vec<_>, CompileError>>()?
             .into_iter()
             .unzip();
 
+        #[cfg_attr(not(feature = "unwind"), allow(unused_mut))]
         let mut unwind_info = UnwindInfo::default();
 
         #[cfg(feature = "unwind")]
@@ -367,10 +305,18 @@ impl CraneliftCompiler {
             .values()
             .collect::<Vec<_>>()
             .into_iter()
-            .map(|sig| make_trampoline_function_call(&*isa, &mut cx, sig))
+            .map(|sig| {
+                make_trampoline_function_call(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &mut cx,
+                    sig,
+                )
+            })
             .collect::<Result<Vec<FunctionBody>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<SignatureIndex, FunctionBody>>();
+            .collect();
         #[cfg(feature = "rayon")]
         let function_call_trampolines = module
             .signatures
@@ -378,11 +324,17 @@ impl CraneliftCompiler {
             .collect::<Vec<_>>()
             .par_iter()
             .map_init(FunctionBuilderContext::new, |cx, sig| {
-                make_trampoline_function_call(&*isa, cx, sig)
+                make_trampoline_function_call(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    cx,
+                    sig,
+                )
             })
             .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());
@@ -394,21 +346,37 @@ impl CraneliftCompiler {
             .imported_function_types()
             .collect::<Vec<_>>()
             .into_iter()
-            .map(|func_type| make_trampoline_dynamic_function(&*isa, &offsets, &mut cx, &func_type))
+            .map(|func_type| {
+                make_trampoline_dynamic_function(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &offsets,
+                    &mut cx,
+                    &func_type,
+                )
+            })
             .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)
+                make_trampoline_dynamic_function(
+                    &self.config().callbacks,
+                    &*isa,
+                    target.triple().architecture,
+                    &offsets,
+                    cx,
+                    func_type,
+                )
             })
             .collect::<Result<Vec<_>, CompileError>>()?
             .into_iter()
-            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+            .collect();
 
         let got = wasmer_compiler::types::function::GOT::empty();
 
@@ -480,7 +448,11 @@ impl Compiler for CraneliftCompiler {
     }
 }
 
-fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &FinalizedMachReloc) -> Relocation {
+fn mach_reloc_to_reloc(
+    module: &ModuleInfo,
+    func_index_map: &cranelift_entity::PrimaryMap<ir::UserExternalNameRef, ir::UserExternalName>,
+    reloc: &FinalizedMachReloc,
+) -> Relocation {
     let FinalizedMachReloc {
         offset,
         kind,
@@ -494,10 +466,11 @@ fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &FinalizedMachReloc) -> Reloc
         }
     };
     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 {
@@ -523,23 +496,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::NullReference | ir::TrapCode::NullI31Ref => {
-            unimplemented!("Null reference not supported")
-        }
-        ir::TrapCode::User(_user_code) => unimplemented!("User trap code not supported"),
-        // ir::TrapCode::Interrupt => TrapCode::Interrupt,
-        // ir::TrapCode::User(user_code) => TrapCode::User(user_code),
+    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 d983cdda6f..11b8c4d8a6 100644
--- a/lib/compiler-cranelift/src/config.rs
+++ b/lib/compiler-cranelift/src/config.rs
@@ -1,14 +1,67 @@
 use crate::compiler::CraneliftCompiler;
 use cranelift_codegen::{
-    isa::{lookup, TargetIsa},
-    settings::{self, Configurable},
     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 wasmer_compiler::{
+    Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware,
+    misc::{CompiledKind, function_kind_to_filename, save_assembly_to_file},
 };
-use std::num::NonZero;
-use std::sync::Arc;
-use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
 use wasmer_types::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 })
+    }
+
+    /// Writes the pre-optimization intermediate representation to a debug file.
+    pub fn preopt_ir(&self, kind: &CompiledKind, mem_buffer: &[u8]) {
+        let mut path = self.debug_dir.clone();
+        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, mem_buffer: &[u8]) {
+        let mut path = self.debug_dir.clone();
+        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,
+        arch: Architecture,
+        mem_buffer: &[u8],
+    ) -> Result<(), wasmer_types::CompileError> {
+        let mut path = self.debug_dir.clone();
+        path.push(function_kind_to_filename(kind, ".s"));
+        save_assembly_to_file(arch, path, mem_buffer, HashMap::<usize, String>::new())
+    }
+}
+
 // Runtime Environment
 
 /// Possible optimization levels for the Cranelift codegen backend.
@@ -41,6 +94,7 @@ pub struct Cranelift {
     pub num_threads: NonZero<usize>,
     /// The middleware chain.
     pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+    pub(crate) callbacks: Option<CraneliftCallbacks>,
 }
 
 impl Cranelift {
@@ -55,6 +109,7 @@ impl Cranelift {
             num_threads: std::thread::available_parallelism().unwrap_or(NonZero::new(1).unwrap()),
             middlewares: vec![],
             enable_perfmap: false,
+            callbacks: None,
         }
     }
 
@@ -131,11 +186,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 {
+    pub fn flags(&self) -> settings::Flags {
         let mut flags = settings::builder();
 
         // Enable probestack
@@ -143,12 +198,10 @@ 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");
-        }
+        // Always use inline stack probes (otherwise the call to Probestack needs to be relocated).
+        flags
+            .set("probestack_strategy", "inline")
+            .expect("should be valid flag");
 
         if self.enable_pic {
             flags.enable("is_pic").expect("should be a valid flag");
@@ -160,6 +213,12 @@ impl Cranelift {
             .enable("use_colocated_libcalls")
             .expect("should be a valid flag");
 
+        // Allow Cranelift to implicitly spill multi-value returns via a hidden
+        // StructReturn argument when register results are exhausted.
+        flags
+            .enable("enable_multi_ret_implicit_sret")
+            .expect("should be a valid flag");
+
         // Invert cranelift's default-on verification to instead default off.
         let enable_verifier = if self.enable_verifier {
             "true"
@@ -169,9 +228,6 @@ impl Cranelift {
         flags
             .set("enable_verifier", enable_verifier)
             .expect("should be valid flag");
-        flags
-            .set("enable_safepoints", "true")
-            .expect("should be valid flag");
 
         flags
             .set(
@@ -195,6 +251,13 @@ impl Cranelift {
 
         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 {
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 68e7582318..deacc4ae26 100644
--- a/lib/compiler-cranelift/src/dwarf.rs
+++ b/lib/compiler-cranelift/src/dwarf.rs
@@ -4,7 +4,7 @@ use wasmer_compiler::types::{
     relocation::{Relocation, RelocationKind, RelocationTarget},
     section::{CustomSection, CustomSectionProtection, SectionBody},
 };
-use wasmer_types::{entity::EntityRef, target::Endianness, LocalFunctionIndex};
+use wasmer_types::{LocalFunctionIndex, entity::EntityRef, target::Endianness};
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {
diff --git a/lib/compiler-cranelift/src/func_environ.rs b/lib/compiler-cranelift/src/func_environ.rs
index 3f01707f40..1868a7cf0b 100644
--- a/lib/compiler-cranelift/src/func_environ.rs
+++ b/lib/compiler-cranelift/src/func_environ.rs
@@ -9,11 +9,11 @@ use crate::{
 use cranelift_codegen::{
     cursor::FuncCursor,
     ir::{
-        self,
+        self, AbiParam, ArgumentPurpose, Function, InstBuilder, MemFlags, Signature,
+        UserExternalName,
         condcodes::IntCC,
         immediates::{Offset32, Uimm64},
         types::*,
-        AbiParam, ArgumentPurpose, Function, InstBuilder, MemFlags, Signature,
     },
     isa::TargetFrontendConfig,
 };
@@ -21,15 +21,18 @@ use cranelift_frontend::FunctionBuilder;
 use std::convert::TryFrom;
 use wasmer_compiler::wasmparser::HeapType;
 use wasmer_types::{
-    entity::{EntityRef, PrimaryMap, SecondaryMap},
     FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, MemoryStyle,
     ModuleInfo, SignatureIndex, TableIndex, TableStyle, Type as WasmerType, VMBuiltinFunctionIndex,
     VMOffsets, WasmError, WasmResult,
+    entity::{EntityRef, PrimaryMap, SecondaryMap},
 };
 
 /// 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.
@@ -267,7 +270,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     // dst
                     AbiParam::new(I32),
                     // value
-                    AbiParam::new(R64),
+                    AbiParam::new(self.reference_type()),
                     // len
                     AbiParam::new(I32),
                 ],
@@ -298,7 +301,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,
             })
         });
@@ -326,7 +329,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,
             })
         });
@@ -361,7 +364,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,
@@ -397,7 +400,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),
                 ],
@@ -1052,22 +1055,20 @@ impl BaseFuncEnvironment for FuncEnvironment<'_> {
     ) -> WasmResult<ir::Value> {
         Ok(match ty {
             HeapType::Abstract { ty, .. } => match ty {
-                wasmer_compiler::wasmparser::AbstractHeapType::Func => {
-                    pos.ins().null(self.reference_type())
-                }
-                wasmer_compiler::wasmparser::AbstractHeapType::Extern => {
-                    pos.ins().null(self.reference_type())
+                wasmer_compiler::wasmparser::AbstractHeapType::Func
+                | wasmer_compiler::wasmparser::AbstractHeapType::Extern => {
+                    pos.ins().iconst(self.reference_type(), 0)
                 }
                 _ => {
                     return Err(WasmError::Unsupported(
                         "`ref.null T` that is not a `funcref` or an `externref`".into(),
-                    ))
+                    ));
                 }
             },
             HeapType::Concrete(_) => {
                 return Err(WasmError::Unsupported(
                     "`ref.null T` that is not a `funcref` or an `externref`".into(),
-                ))
+                ));
             }
         })
     }
@@ -1077,17 +1078,9 @@ impl BaseFuncEnvironment for FuncEnvironment<'_> {
         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))
     }
 
@@ -1262,7 +1255,8 @@ impl BaseFuncEnvironment for FuncEnvironment<'_> {
     ) -> 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,
@@ -1290,7 +1284,7 @@ impl BaseFuncEnvironment for FuncEnvironment<'_> {
         // check if the funcref is null
         builder
             .ins()
-            .trapz(anyfunc_ptr, ir::TrapCode::IndirectCallToNull);
+            .trapz(anyfunc_ptr, crate::TRAP_INDIRECT_CALL_TO_NULL);
 
         let func_addr = builder.ins().load(
             pointer_type,
@@ -1327,7 +1321,7 @@ impl BaseFuncEnvironment for FuncEnvironment<'_> {
                 let cmp = builder
                     .ins()
                     .icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
-                builder.ins().trapz(cmp, ir::TrapCode::BadSignature);
+                builder.ins().trapz(cmp, crate::TRAP_BAD_SIGNATURE);
             }
         }
 
diff --git a/lib/compiler-cranelift/src/lib.rs b/lib/compiler-cranelift/src/lib.rs
index 5d8857f3ed..47301f01a5 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;
@@ -50,10 +48,34 @@ 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
index b1dc08787e..6136e132ce 100644
--- a/lib/compiler-cranelift/src/table.rs
+++ b/lib/compiler-cranelift/src/table.rs
@@ -1,5 +1,5 @@
 use cranelift_codegen::cursor::FuncCursor;
-use cranelift_codegen::ir::{self, condcodes::IntCC, immediates::Imm64, InstBuilder};
+use cranelift_codegen::ir::{self, InstBuilder, condcodes::IntCC, immediates::Imm64};
 use cranelift_frontend::FunctionBuilder;
 
 /// Size of a WebAssembly table, in elements.
@@ -62,7 +62,7 @@ impl TableData {
             .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
 
         if !enable_table_access_spectre_mitigation {
-            pos.ins().trapnz(oob, ir::TrapCode::TableOutOfBounds);
+            pos.ins().trapnz(oob, crate::TRAP_TABLE_OUT_OF_BOUNDS);
         }
 
         // Convert `index` to `addr_ty`.
@@ -95,7 +95,7 @@ impl TableData {
             let zero = pos.ins().iconst(addr_ty, 0);
             (
                 pos.ins().select_spectre_guard(oob, zero, element_addr),
-                base_flags.with_trap_code(Some(ir::TrapCode::TableOutOfBounds)),
+                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 ead1caa3f9..804d312564 100644
--- a/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
+++ b/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
@@ -3,20 +3,26 @@
 
 //! A trampoline generator for calling dynamic host functions from Wasm.
 
-use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
+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,
-    Context,
 };
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use std::{cmp, mem};
-use wasmer_compiler::types::function::FunctionBody;
+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,
@@ -102,10 +108,31 @@ pub fn make_trampoline_dynamic_function(
         builder.finalize()
     }
 
+    if let Some(callbacks) = callbacks.as_ref() {
+        callbacks.preopt_ir(
+            &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+            context.func.display().to_string().as_bytes(),
+        );
+    }
+
     let mut code_buf = Vec::new();
-    context
-        .compile_and_emit(isa, &mut code_buf, &mut Default::default())
+    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()),
+            &code_buf,
+        );
+        callbacks.asm_memory_buffer(
+            &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+            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 ebe874f0b3..ca5c963618 100644
--- a/lib/compiler-cranelift/src/trampoline/function_call.rs
+++ b/lib/compiler-cranelift/src/trampoline/function_call.rs
@@ -8,20 +8,26 @@
 //! let my_func = instance.exports.get("func");
 //! my_func.call([1, 2])
 //! ```
-use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
+use crate::{
+    CraneliftCallbacks,
+    translator::{compiled_function_unwind_info, signature_to_cranelift_ir},
+};
 use cranelift_codegen::{
+    Context,
     ir::{self, InstBuilder},
     isa::TargetIsa,
-    Context,
 };
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use std::mem;
-use wasmer_compiler::types::function::FunctionBody;
+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,
 ) -> Result<FunctionBody, CompileError> {
@@ -102,11 +108,31 @@ 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()),
+            context.func.display().to_string().as_bytes(),
+        );
+    }
 
-    context
-        .compile_and_emit(isa, &mut code_buf, &mut Default::default())
+    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()),
+            &code_buf,
+        );
+        callbacks.asm_memory_buffer(
+            &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+            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 b02d1b613a..842e350236 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.
@@ -79,13 +79,14 @@ mod bounds_checks;
 use super::func_environ::{FuncEnvironment, GlobalVariable};
 use super::func_state::{ControlStackFrame, ElseData, FuncTranslationState};
 use super::translation_utils::{block_with_params, f32_translation, f64_translation};
-use crate::{hash_map, HashMap};
+use crate::{HashMap, hash_map};
 use core::convert::TryFrom;
 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};
@@ -94,7 +95,7 @@ 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::{ModuleTranslationState, from_binaryreadererror_wasmerror, wasm_unsupported};
 use wasmer_types::{
     FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
 };
@@ -106,7 +107,7 @@ use wasmer_types::{
 /// when we can statically determine that a Wasm access will unconditionally
 /// trap.
 macro_rules! unwrap_or_return_unreachable_state {
-    ($state:ident, $value:expr) => {
+    ($state:ident, $value:expr_2021) => {
         match $value {
             Reachability::Reachable(x) => x,
             Reachability::Unreachable => {
@@ -252,7 +253,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             // We do nothing
         }
         Operator::Unreachable => {
-            builder.ins().trap(ir::TrapCode::UnreachableCodeReached);
+            builder.ins().trap(crate::TRAP_UNREACHABLE);
             state.reachable = false;
         }
         /***************************** Control flow blocks **********************************
@@ -1196,7 +1197,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) => {
@@ -2243,13 +2244,13 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::GlobalAtomicRmwXor { .. }
         | Operator::GlobalAtomicRmwXchg { .. }
         | Operator::GlobalAtomicRmwCmpxchg { .. } => {
-            return Err(wasm_unsupported!("Global atomics not supported yet!"))
+            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!"))
+            return Err(wasm_unsupported!("Table atomics not supported yet!"));
         }
         Operator::StructAtomicGet { .. }
         | Operator::StructAtomicGetS { .. }
@@ -2262,7 +2263,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::StructAtomicRmwXor { .. }
         | Operator::StructAtomicRmwXchg { .. }
         | Operator::StructAtomicRmwCmpxchg { .. } => {
-            return Err(wasm_unsupported!("Table atomics not supported yet!"))
+            return Err(wasm_unsupported!("Table atomics not supported yet!"));
         }
         Operator::ArrayAtomicGet { .. }
         | Operator::ArrayAtomicGetS { .. }
@@ -2275,7 +2276,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::ArrayAtomicRmwXor { .. }
         | Operator::ArrayAtomicRmwXchg { .. }
         | Operator::ArrayAtomicRmwCmpxchg { .. } => {
-            return Err(wasm_unsupported!("Array atomics not supported yet!"))
+            return Err(wasm_unsupported!("Array atomics not supported yet!"));
         }
         Operator::ContNew { .. } => todo!(),
         Operator::ContBind { .. } => todo!(),
@@ -2573,7 +2574,7 @@ where
             let adjusted_index =
                 builder
                     .ins()
-                    .uadd_overflow_trap(index, offset, ir::TrapCode::HeapOutOfBounds);
+                    .uadd_overflow_trap(index, offset, ir::TrapCode::HEAP_OUT_OF_BOUNDS);
             bounds_checks::bounds_check_and_compute_addr(
                 builder,
                 environ,
@@ -2641,7 +2642,7 @@ fn align_atomic_addr(
             .ins()
             .band_imm(effective_addr, i64::from(loaded_bytes - 1));
         let f = builder.ins().icmp_imm(IntCC::NotEqual, misalignment, 0);
-        builder.ins().trapnz(f, ir::TrapCode::HeapMisaligned);
+        builder.ins().trapnz(f, crate::TRAP_HEAP_MISALIGNED);
     }
 }
 
@@ -2759,7 +2760,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
@@ -2771,7 +2772,7 @@ 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
 }
 
@@ -2795,7 +2796,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);
@@ -2844,7 +2845,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);
@@ -2893,7 +2894,7 @@ 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);
@@ -2935,7 +2936,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);
@@ -3259,22 +3260,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),
@@ -3282,7 +3274,8 @@ fn canonicalise_v128_values<'a>(
             )
         } else {
             *v
-        });
+        };
+        tmp_canonicalised.push(BlockArg::from(value));
     }
     tmp_canonicalised.as_slice()
 }
@@ -3295,7 +3288,7 @@ 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)
 }
@@ -3309,10 +3302,10 @@ fn canonicalise_brif(
     block_else: ir::Block,
     params_else: &[ir::Value],
 ) -> ir::Inst {
-    let mut tmp_canonicalised_then = SmallVec::<[ir::Value; 16]>::new();
+    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::<[ir::Value; 16]>::new();
+    let mut tmp_canonicalised_else = SmallVec::<[_; 16]>::new();
     let canonicalised_else =
         canonicalise_v128_values(&mut tmp_canonicalised_else, builder, params_else);
     builder.ins().brif(
diff --git a/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs b/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs
index 58b8c13c31..bae55f7957 100644
--- a/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs
+++ b/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs
@@ -24,14 +24,14 @@ use crate::{
     heap::{HeapData, HeapStyle},
     translator::func_environ::FuncEnvironment,
 };
+use Reachability::*;
 use cranelift_codegen::{
     cursor::{Cursor, FuncCursor},
-    ir::{self, condcodes::IntCC, InstBuilder, RelSourceLoc},
+    ir::{self, InstBuilder, RelSourceLoc, condcodes::IntCC},
     ir::{Expr, Fact},
 };
 use cranelift_frontend::FunctionBuilder;
 use wasmer_types::WasmResult;
-use Reachability::*;
 
 /// Helper used to emit bounds checks (as necessary) and compute the native
 /// address of a heap access.
@@ -281,7 +281,7 @@ where
             let adjusted_index = builder.ins().uadd_overflow_trap(
                 index,
                 access_size_val,
-                ir::TrapCode::HeapOutOfBounds,
+                ir::TrapCode::HEAP_OUT_OF_BOUNDS,
             );
             if pcc {
                 builder.func.dfg.facts[adjusted_index] = Some(Fact::value_offset(
@@ -326,7 +326,7 @@ where
                 "static memories require the ability to use virtual memory"
             );
             env.before_unconditionally_trapping_memory_access(builder)?;
-            builder.ins().trap(ir::TrapCode::HeapOutOfBounds);
+            builder.ins().trap(ir::TrapCode::HEAP_OUT_OF_BOUNDS);
             Unreachable
         }
 
@@ -568,7 +568,7 @@ fn explicit_check_oob_condition_and_compute_addr(
 ) -> ir::Value {
     if !spectre_mitigations_enabled {
         pos.ins()
-            .trapnz(oob_condition, ir::TrapCode::HeapOutOfBounds);
+            .trapnz(oob_condition, ir::TrapCode::HEAP_OUT_OF_BOUNDS);
     }
 
     let mut addr = compute_addr(pos, heap, addr_ty, index, offset, pcc);
diff --git a/lib/compiler-cranelift/src/translator/func_environ.rs b/lib/compiler-cranelift/src/translator/func_environ.rs
index a732a39ae0..e53a0cb810 100644
--- a/lib/compiler-cranelift/src/translator/func_environ.rs
+++ b/lib/compiler-cranelift/src/translator/func_environ.rs
@@ -70,7 +70,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")
     }
@@ -296,7 +296,7 @@ pub trait FuncEnvironment: TargetEnvironment {
 
     /// Translate a `table.size` WebAssembly instruction.
     fn translate_table_size(&mut self, pos: FuncCursor, index: TableIndex)
-        -> WasmResult<ir::Value>;
+    -> WasmResult<ir::Value>;
 
     /// Translate a `table.grow` WebAssembly instruction.
     fn translate_table_grow(
@@ -370,11 +370,10 @@ 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;
+        Ok(pos.ins().iconst(self.reference_type(), 0))
+    }
 
     /// Translate a `ref.is_null` WebAssembly instruction.
     ///
@@ -389,8 +388,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.
diff --git a/lib/compiler-cranelift/src/translator/func_translator.rs b/lib/compiler-cranelift/src/translator/func_translator.rs
index 6ae1b40903..363344bb4b 100644
--- a/lib/compiler-cranelift/src/translator/func_translator.rs
+++ b/lib/compiler-cranelift/src/translator/func_translator.rs
@@ -12,12 +12,13 @@ use super::func_environ::{FuncEnvironment, ReturnMode};
 use super::func_state::FuncTranslationState;
 use super::translation_utils::get_vmctx_value_label;
 use crate::translator::code_translator::bitcast_wasm_returns;
+use 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::{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.
@@ -137,8 +138,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];
@@ -197,7 +200,7 @@ 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 {
                 return Err(wasm_unsupported!("unsupported reference type: {:?}", ty));
             }
@@ -207,8 +210,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);
diff --git a/lib/compiler-cranelift/src/translator/mod.rs b/lib/compiler-cranelift/src/translator/mod.rs
index accc867c46..e39037bc6c 100644
--- a/lib/compiler-cranelift/src/translator/mod.rs
+++ b/lib/compiler-cranelift/src/translator/mod.rs
@@ -12,4 +12,6 @@ pub use self::func_translator::FuncTranslator;
 pub use self::translation_utils::{
     irlibcall_to_libcall, irreloc_to_relocationkind, signature_to_cranelift_ir,
 };
-pub(crate) use self::unwind::{compiled_function_unwind_info, CraneliftUnwindInfo};
+#[cfg(feature = "unwind")]
+pub(crate) use self::unwind::CraneliftUnwindInfo;
+pub(crate) use self::unwind::compiled_function_unwind_info;
diff --git a/lib/compiler-cranelift/src/translator/translation_utils.rs b/lib/compiler-cranelift/src/translator/translation_utils.rs
index 81a4d835d8..88419ac2ed 100644
--- a/lib/compiler-cranelift/src/translator/translation_utils.rs
+++ b/lib/compiler-cranelift/src/translator/translation_utils.rs
@@ -1,7 +1,6 @@
 //! Helper functions and structures for the translation.
 
 use super::func_environ::TargetEnvironment;
-use crate::std::string::ToString;
 use cranelift_codegen::{
     binemit::Reloc,
     ir::{self, AbiParam},
@@ -37,13 +36,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.
diff --git a/lib/compiler-cranelift/src/translator/unwind.rs b/lib/compiler-cranelift/src/translator/unwind.rs
index ceddcbd505..ed0510ef09 100644
--- a/lib/compiler-cranelift/src/translator/unwind.rs
+++ b/lib/compiler-cranelift/src/translator/unwind.rs
@@ -2,8 +2,10 @@
 //! module.
 
 #[cfg(feature = "unwind")]
-use cranelift_codegen::isa::unwind::{systemv::UnwindInfo as DwarfFDE, UnwindInfo};
-use cranelift_codegen::{isa, print_errors::pretty_error, Context};
+use cranelift_codegen::isa::unwind::{UnwindInfo, systemv::UnwindInfo as DwarfFDE};
+#[cfg(feature = "unwind")]
+use cranelift_codegen::print_errors::pretty_error;
+use cranelift_codegen::{Context, isa};
 use wasmer_compiler::types::unwind::CompiledFunctionUnwindInfo;
 use wasmer_types::CompileError;
 
@@ -62,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 853cdb66e9..eb074ffca7 100644
--- a/lib/compiler-llvm/Cargo.toml
+++ b/lib/compiler-llvm/Cargo.toml
@@ -20,33 +20,28 @@ wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = [
 ] }
 wasmer-vm = { path = "../vm", version = "=6.1.0" }
 wasmer-types = { path = "../types", version = "=6.1.0" }
-target-lexicon = { workspace = true, default-features = false }
+target-lexicon = { workspace = true }
 smallvec.workspace = true
 object = { workspace = true, features = ["read"] }
 libc.workspace = true
 byteorder.workspace = true
 itertools.workspace = true
 rayon.workspace = true
-phf = { version = "0.11.2", features = ["macros"] }
+phf = { workspace = true, features = ["macros"] }
 tracing = { workspace = true, features = ["log"] }
-
-[dependencies.inkwell]
-package = "inkwell"
-version = "0.5.0"
-default-features = false
-features = [
-	"llvm18-0-prefer-static",
+inkwell = { workspace = true, features = [
+	"llvm21-1-prefer-static",
 	"target-x86",
 	"target-aarch64",
 	"target-riscv",
 	"target-loongarch",
-]
+] }
 
 [build-dependencies]
-cc = "1.0"
-regex = "1.5"
+cc.workspace = true
+regex.workspace = true
 semver.workspace = true
-rustc_version = "0.4"
+rustc_version.workspace = true
 
 [features]
 test = []
diff --git a/lib/compiler-llvm/LICENSE b/lib/compiler-llvm/LICENSE
index 622ebe383d..c225bd62f9 100644
--- a/lib/compiler-llvm/LICENSE
+++ b/lib/compiler-llvm/LICENSE
@@ -4,7 +4,7 @@ License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
 Parameters
 
 Licensor:             Wasmer, Inc.
-Licensed Work:        Wasmer LLVM Version 6.0.0 or later.  The Licensed Work is
+Licensed Work:        Wasmer LLVM Version 6.1.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
@@ -34,6 +34,12 @@ Additional Use Grant: You may make production use of the Licensed Work provided
                       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.
+
+                      For purposes of this License, any code, binaries, or other output
+                      generated by the Licensed Work ("Generated Code") shall be deemed part
+                      of the Licensed Work and subject to the same terms, conditions, and
+                      restrictions as the Licensed Work itself, including the limitations on
+                      production use and the Change Date.
 Change Date:          Four years from the date the Licensed Work is published
 Change License:       MPL 2.0
 
@@ -83,4 +89,4 @@ TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
 AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
 EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
-TITLE.
\ No newline at end of file
+TITLE.
diff --git a/lib/compiler-llvm/README.md b/lib/compiler-llvm/README.md
index e2d789068c..eec852844c 100644
--- a/lib/compiler-llvm/README.md
+++ b/lib/compiler-llvm/README.md
@@ -23,20 +23,20 @@ to native speeds.
 ## Requirements
 
 The LLVM compiler requires a valid installation of LLVM in your system.
-It currently requires **LLVM 18**.
+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 18
+sudo bash /tmp/llvm.sh 21
 ```
 
 Or in macOS:
 
 ```bash
-brew install llvm@18
+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 2076f62962..b4a9aa37eb 100644
--- a/lib/compiler-llvm/src/abi/aarch64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/aarch64_systemv.rs
@@ -1,13 +1,13 @@
 use crate::abi::Abi;
 use crate::error::{err, err_nt};
-use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+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, FunctionValue, IntValue, PointerValue},
-    AddressSpace,
 };
 use wasmer_types::CompileError;
 use wasmer_types::{FunctionType as FuncSig, Type};
@@ -412,7 +412,7 @@ impl Abi for Aarch64SystemV {
                 }
             };
 
-        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);
@@ -514,12 +514,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
@@ -600,9 +598,11 @@ impl Abi for Aarch64SystemV {
             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()))
+            err_nt!(
+                builder
+                    .build_or(low, high, "")
+                    .map(|v| v.as_basic_value_enum())
+            )
         };
 
         let to_i64 = |v: BasicValueEnum<'ctx>| -> Result<BasicValueEnum<'_>, CompileError> {
diff --git a/lib/compiler-llvm/src/abi/x86_64_systemv.rs b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
index f0bad7fb01..000d2c8f60 100644
--- a/lib/compiler-llvm/src/abi/x86_64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
@@ -1,7 +1,8 @@
 use crate::abi::Abi;
 use crate::error::{err, err_nt};
-use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+use crate::translator::intrinsics::{Intrinsics, type_to_llvm};
 use inkwell::{
+    AddressSpace,
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     context::Context,
@@ -10,7 +11,6 @@ use inkwell::{
         BasicValue, BasicValueEnum, CallSiteValue, FloatValue, FunctionValue, IntValue,
         PointerValue, VectorValue,
     },
-    AddressSpace,
 };
 use wasmer_types::{CompileError, FunctionType as FuncSig, Type};
 use wasmer_vm::VMOffsets;
@@ -438,7 +438,7 @@ impl Abi for X86_64SystemV {
                 }
             };
 
-        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);
@@ -548,12 +548,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
@@ -637,9 +635,11 @@ impl Abi for X86_64SystemV {
             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()))
+            err_nt!(
+                builder
+                    .build_or(low, high, "")
+                    .map(|v| v.as_basic_value_enum())
+            )
         };
 
         let pack_f32s = |first: BasicValueEnum<'ctx>,
@@ -655,9 +655,11 @@ impl Abi for X86_64SystemV {
                 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()))
+            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>]| {
diff --git a/lib/compiler-llvm/src/compiler.rs b/lib/compiler-llvm/src/compiler.rs
index 376dd03207..bd228ea7fe 100644
--- a/lib/compiler-llvm/src/compiler.rs
+++ b/lib/compiler-llvm/src/compiler.rs
@@ -1,28 +1,28 @@
 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 rayon::ThreadPoolBuilder;
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
+use wasmer_compiler::misc::CompiledKind;
 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},
     },
-    Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState,
 };
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::target::Target;
@@ -114,7 +114,7 @@ impl ModuleBasedSymbolRegistry {
     }
 
     // If the name starts with a problematic prefix, we prefix it with an underscore.
-    fn fixup_problematic_name(name: &str) -> Cow<str> {
+    fn fixup_problematic_name(name: &str) -> Cow<'_, str> {
         for prefix in Self::PROBLEMATIC_PREFIXES {
             if name.starts_with(prefix) {
                 return format!("_{name}").into();
@@ -194,6 +194,7 @@ impl LLVMCompiler {
                     &compile_info.memory_styles,
                     &compile_info.table_styles,
                     symbol_registry,
+                    target.triple(),
                 )?;
 
                 Ok(module.write_bitcode_to_memory().as_slice().to_vec())
@@ -410,6 +411,7 @@ impl Compiler for LLVMCompiler {
                                 memory_styles,
                                 table_styles,
                                 &symbol_registry,
+                                target.triple(),
                             )
                         },
                     )
@@ -436,6 +438,7 @@ impl Compiler for LLVMCompiler {
                         memory_styles,
                         table_styles,
                         &symbol_registry,
+                        target.triple(),
                     )
                 })
                 .collect::<Result<Vec<_>, CompileError>>()?
@@ -469,6 +472,8 @@ impl Compiler for LLVMCompiler {
                             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.
                         module_custom_sections.push(CustomSection {
@@ -514,35 +519,6 @@ impl Compiler for LLVMCompiler {
             })
             .collect::<PrimaryMap<LocalFunctionIndex, _>>();
 
-        let mut unwind_info = UnwindInfo::default();
-
-        if !eh_frame_section_bytes.is_empty() {
-            let eh_frame_idx = SectionIndex::from_u32(module_custom_sections.len() as u32);
-            // Terminate the eh_frame info with a zero-length CIE.
-            //
-            // There may be more info added later in lib/object/src/module.rs emit_compilation
-            // but that's okay, because an eh_frame can have multiple CIEs.
-            eh_frame_section_bytes.extend_from_slice(&[0, 0, 0, 0]);
-            module_custom_sections.push(CustomSection {
-                protection: CustomSectionProtection::Read,
-                alignment: None,
-                bytes: SectionBody::new_with_vec(eh_frame_section_bytes),
-                relocations: eh_frame_section_relocations,
-            });
-            unwind_info.eh_frame = Some(eh_frame_idx);
-        }
-
-        if !compact_unwind_section_bytes.is_empty() {
-            let cu_index = SectionIndex::from_u32(module_custom_sections.len() as u32);
-            module_custom_sections.push(CustomSection {
-                protection: CustomSectionProtection::Read,
-                alignment: None,
-                bytes: SectionBody::new_with_vec(compact_unwind_section_bytes),
-                relocations: compact_unwind_section_relocations,
-            });
-            unwind_info.compact_unwind = Some(cu_index);
-        }
-
         let function_call_trampolines = if self.config.num_threads.get() > 1 {
             let pool = ThreadPoolBuilder::new()
                 .num_threads(self.config.num_threads.get())
@@ -581,42 +557,60 @@ impl Compiler for LLVMCompiler {
                 .collect::<Result<PrimaryMap<_, _>, CompileError>>()?
         };
 
-        let dynamic_function_trampolines = if self.config.num_threads.get() > 1 {
-            let pool = ThreadPoolBuilder::new()
-                .num_threads(self.config.num_threads.get())
-                .build()
-                .map_err(|e| CompileError::Resource(e.to_string()))?;
-            pool.install(|| {
-                module
-                    .imported_function_types()
-                    .collect::<Vec<_>>()
-                    .par_iter()
-                    .map_init(
-                        || {
-                            let target_machine = self.config().target_machine(target);
-                            FuncTrampoline::new(target_machine, binary_format).unwrap()
-                        },
-                        |func_trampoline, func_type| {
-                            func_trampoline.dynamic_trampoline(func_type, self.config(), "")
-                        },
-                    )
-                    .collect::<Vec<_>>()
-                    .into_iter()
-                    .collect::<Result<PrimaryMap<_, _>, CompileError>>()
-            })?
-        } else {
+        // 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 target_machine = self.config().target_machine(target);
             let func_trampoline = FuncTrampoline::new(target_machine, binary_format).unwrap();
             module
                 .imported_function_types()
                 .collect::<Vec<_>>()
                 .into_iter()
-                .map(|func_type| func_trampoline.dynamic_trampoline(&func_type, self.config(), ""))
+                .enumerate()
+                .map(|(index, func_type)| {
+                    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,
+                    )
+                })
                 .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,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(eh_frame_section_bytes),
+                relocations: eh_frame_section_relocations,
+            });
+            unwind_info.eh_frame = Some(eh_frame_idx);
+        }
+
+        if !compact_unwind_section_bytes.is_empty() {
+            let cu_index = SectionIndex::from_u32(module_custom_sections.len() as u32);
+            module_custom_sections.push(CustomSection {
+                protection: CustomSectionProtection::Read,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(compact_unwind_section_bytes),
+                relocations: compact_unwind_section_relocations,
+            });
+            unwind_info.compact_unwind = Some(cu_index);
+        }
+
         let mut got = wasmer_compiler::types::function::GOT::empty();
 
         if !got_targets.is_empty() {
diff --git a/lib/compiler-llvm/src/config.rs b/lib/compiler-llvm/src/config.rs
index 1a0261b0b4..3fcf077448 100644
--- a/lib/compiler-llvm/src/config.rs
+++ b/lib/compiler-llvm/src/config.rs
@@ -1,17 +1,21 @@
 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::fs::File;
+use std::io::{self, Write};
+use std::path::PathBuf;
 use std::sync::Arc;
 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::{
+    Features,
     target::{Architecture, OperatingSystem, Target, Triple},
-    Features, FunctionType, LocalFunctionIndex,
 };
 
 /// The InkWell ModuleInfo type
@@ -20,25 +24,50 @@ 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);
-    fn asm_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 })
+    }
+
+    pub fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+        let mut path = self.debug_dir.clone();
+        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: &InkwellModule) {
+        let mut path = self.debug_dir.clone();
+        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, memory_buffer: &InkwellMemoryBuffer) {
+        let mut path = self.debug_dir.clone();
+        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, asm_memory_buffer: &InkwellMemoryBuffer) {
+        let mut path = self.debug_dir.clone();
+        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)]
@@ -49,7 +78,7 @@ pub struct LLVM {
     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.
@@ -94,7 +123,7 @@ impl LLVM {
 
     /// 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
     }
@@ -129,21 +158,22 @@ impl LLVM {
     }
 
     pub(crate) fn target_operating_system(&self, target: &Target) -> OperatingSystem {
-        if target.triple().operating_system == OperatingSystem::Darwin && !self.is_pic {
-            // LLVM detects static relocation + darwin + 64-bit and
-            // force-enables PIC because MachO doesn't support that
-            // combination. They don't check whether they're targeting
-            // 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,
-                _ => OperatingSystem::Linux,
+        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,
+                }
             }
-        } else {
-            target.triple().operating_system
+            other => other,
         }
     }
 
@@ -152,7 +182,7 @@ impl LLVM {
             target.triple().binary_format
         } else {
             match self.target_operating_system(target) {
-                OperatingSystem::Darwin => target_lexicon::BinaryFormat::Macho,
+                OperatingSystem::Darwin(_) => target_lexicon::BinaryFormat::Macho,
                 _ => target_lexicon::BinaryFormat::Elf,
             }
         }
@@ -245,61 +275,29 @@ impl LLVM {
 
         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",
-                    Architecture::LoongArch64 => "generic-la64",
-                    _ => "generic",
-                },
-                match triple.architecture {
-                    Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
-                    Architecture::LoongArch64 => "+f,+d",
-                    _ => &llvm_cpu_features,
-                },
-                self.opt_level,
-                self.reloc_mode(self.target_binary_format(target)),
-                match triple.architecture {
-                    Architecture::LoongArch64 | Architecture::Riscv64(_) => CodeModel::Medium,
-                    _ => self.code_model(self.target_binary_format(target)),
-                },
-            )
-            .unwrap();
-
+        let mut llvm_target_machine_options = TargetMachineOptions::new()
+            .set_cpu(match triple.architecture {
+                Architecture::Riscv64(_) => "generic-rv64",
+                Architecture::LoongArch64 => "generic-la64",
+                _ => "generic",
+            })
+            .set_features(match triple.architecture {
+                Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
+                Architecture::LoongArch64 => "+f,+d",
+                _ => &llvm_cpu_features,
+            })
+            .set_level(self.opt_level)
+            .set_reloc_mode(self.reloc_mode(self.target_binary_format(target)))
+            .set_code_model(match triple.architecture {
+                Architecture::LoongArch64 | Architecture::Riscv64(_) => CodeModel::Medium,
+                _ => self.code_model(self.target_binary_format(target)),
+            });
         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,
-                }
-                // 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(
-                    c"lp64d".as_ptr(),
-                    (my_target_machine.target_machine as *mut i8).offset(0x418),
-                    6,
-                );
-
-                std::mem::transmute::<MyTargetMachine, inkwell::targets::TargetMachine>(
-                    my_target_machine,
-                )
-            }
-        } else {
-            llvm_target_machine
+            llvm_target_machine_options = llvm_target_machine_options.set_abi("lp64d");
         }
+        llvm_target
+            .create_target_machine_from_options(&target_triple, llvm_target_machine_options)
+            .unwrap()
     }
 }
 
diff --git a/lib/compiler-llvm/src/error.rs b/lib/compiler-llvm/src/error.rs
index 0ebe4ade2c..91159de8cd 100644
--- a/lib/compiler-llvm/src/error.rs
+++ b/lib/compiler-llvm/src/error.rs
@@ -1,11 +1,11 @@
 macro_rules! err_nt {
-    ($e: expr) => {
+    ($e: expr_2021) => {
         $e.map_err(|v| CompileError::Codegen(v.to_string()))
     };
 }
 
 macro_rules! err {
-    ($e: expr) => {
+    ($e: expr_2021) => {
         $e.map_err(|v| CompileError::Codegen(v.to_string()))?
     };
 }
diff --git a/lib/compiler-llvm/src/lib.rs b/lib/compiler-llvm/src/lib.rs
index fc07773983..6ef214c60c 100644
--- a/lib/compiler-llvm/src/lib.rs
+++ b/lib/compiler-llvm/src/lib.rs
@@ -12,7 +12,7 @@
 )]
 #![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;
@@ -23,6 +23,4 @@ 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 e6392e5d8a..a148507247 100644
--- a/lib/compiler-llvm/src/object_file.rs
+++ b/lib/compiler-llvm/src/object_file.rs
@@ -5,7 +5,7 @@ use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use std::num::TryFromIntError;
 
-use wasmer_types::{entity::PrimaryMap, CompileError, SourceLoc};
+use wasmer_types::{CompileError, SourceLoc, entity::PrimaryMap};
 
 use wasmer_compiler::types::{
     address_map::{FunctionAddressMap, InstructionAddressMap},
@@ -30,6 +30,7 @@ pub struct 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>,
 }
 
 static LIBCALLS_ELF: phf::Map<&'static str, LibCall> = phf::phf_map! {
@@ -78,13 +79,12 @@ static LIBCALLS_ELF: phf::Map<&'static str, LibCall> = phf::phf_map! {
     "wasmer_vm_memory32_atomic_notify" => LibCall::Memory32AtomicNotify,
     "wasmer_vm_imported_memory32_atomic_notify" => LibCall::ImportedMemory32AtomicNotify,
     "wasmer_vm_throw" => LibCall::Throw,
-    "wasmer_vm_rethrow" => LibCall::Rethrow,
     "wasmer_vm_alloc_exception" => LibCall::AllocException,
-    "wasmer_vm_delete_exception" => LibCall::DeleteException,
-    "wasmer_vm_read_exception" => LibCall::ReadException,
-    "wasmer_vm_dbg_usize" => LibCall::DebugUsize,
+    "wasmer_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,
 };
 
@@ -133,18 +133,18 @@ static LIBCALLS_MACHO: phf::Map<&'static str, LibCall> = phf::phf_map! {
     "_wasmer_vm_imported_memory32_atomic_wait64" => LibCall::ImportedMemory32AtomicWait64,
     "_wasmer_vm_memory32_atomic_notify" => LibCall::Memory32AtomicNotify,
     "_wasmer_vm_imported_memory32_atomic_notify" => LibCall::ImportedMemory32AtomicNotify,
+
     "_wasmer_vm_throw" => LibCall::Throw,
-    "_wasmer_vm_rethrow" => LibCall::Rethrow,
     "_wasmer_vm_alloc_exception" => LibCall::AllocException,
-    "_wasmer_vm_delete_exception" => LibCall::DeleteException,
-    "_wasmer_vm_read_exception" => LibCall::ReadException,
-    "_wasmer_vm_dbg_usize" => LibCall::DebugUsize,
+    "_wasmer_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,
 };
 
@@ -166,7 +166,7 @@ where
         _ => {
             return Err(CompileError::UnsupportedTarget(format!(
                 "Unsupported binary format {binary_fmt:?}"
-            )))
+            )));
         }
     };
 
@@ -221,6 +221,12 @@ where
     // 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![];
+
     for section in obj.sections() {
         let index = section.index();
         if section.kind() == object::SectionKind::Elf(object::elf::SHT_X86_64_UNWIND)
@@ -235,6 +241,11 @@ where
             worklist.push(index);
             compact_unwind_section_indices.push(index);
 
+            elf_section_to_target(index);
+        } else if section.name().unwrap_or_default() == ".gcc_except_table" {
+            worklist.push(index);
+            gcc_except_table_section_indices.push(index);
+
             elf_section_to_target(index);
         }
     }
@@ -277,22 +288,27 @@ where
                         reloc_target
                     } else if let object::SymbolSection::Section(section_index) = symbol.section() {
                         if matches!(
-                            reloc.kind(),
-                            object::RelocationKind::MachO {
-                                value: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
-                                relative: false
-                            } | object::RelocationKind::MachO {
-                                value: object::macho::ARM64_RELOC_POINTER_TO_GOT,
-                                relative: true
-                            } | object::RelocationKind::MachO {
-                                value: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
-                                relative: true
-                            } | object::RelocationKind::MachO {
-                                value: object::macho::ARM64_RELOC_PAGE21,
-                                relative: true
-                            } | object::RelocationKind::MachO {
-                                value: object::macho::ARM64_RELOC_PAGEOFF12,
-                                relative: false
+                            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`
@@ -373,198 +389,243 @@ where
                     )));
                 }
             };
-            let kind = match (obj.architecture(), reloc.kind(), reloc.size()) {
-                (_, object::RelocationKind::Absolute, 64) => RelocationKind::Abs8,
-                (_, object::RelocationKind::Absolute, 32) => RelocationKind::Abs4,
+            let kind = match (obj.architecture(), reloc.flags(), reloc.size()) {
+                (
+                    _,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_X86_64_64,
+                    },
+                    64,
+                ) => RelocationKind::Abs8,
+                (
+                    _,
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_386_32,
+                    },
+                    32,
+                ) => RelocationKind::Abs4,
                 (
                     object::Architecture::X86_64,
-                    object::RelocationKind::Elf(object::elf::R_X86_64_PC64),
+                    object::RelocationFlags::Elf {
+                        r_type: 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),
+                    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::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G1_NC),
+                    object::RelocationFlags::Elf {
+                        r_type: 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),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G2_NC,
+                    },
                     0,
                 ) => RelocationKind::Arm64Movw2,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G3),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_MOVW_UABS_G3,
+                    },
                     0,
                 ) => RelocationKind::Arm64Movw3,
                 (
                     object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_CALL_PLT),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_CALL_PLT,
+                    },
                     0,
                 ) => RelocationKind::RiscvCall,
                 (
                     object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_HI20),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_PCREL_HI20,
+                    },
                     0,
                 ) => RelocationKind::RiscvPCRelHi20,
                 (
                     object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_LO12_I),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_RISCV_PCREL_LO12_I,
+                    },
                     0,
                 ) => RelocationKind::RiscvPCRelLo12I,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS_HI20),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS_HI20,
+                    },
                     0,
                 ) => RelocationKind::LArchAbsHi20,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS_LO12),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS_LO12,
+                    },
                     0,
                 ) => RelocationKind::LArchAbsLo12,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS64_HI12),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS64_HI12,
+                    },
                     0,
                 ) => RelocationKind::LArchAbs64Hi12,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS64_LO20),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_ABS64_LO20,
+                    },
                     0,
                 ) => RelocationKind::LArchAbs64Lo20,
                 (
                     object::Architecture::LoongArch64,
-                    // FIXME: Replace with R_LARCH_CALL36 while object is updated
-                    // to 0.32.2.
-                    // https://github.com/gimli-rs/object/commit/16b6d902f6c9b39ec7aaea141460f8981e57dd79
-                    object::RelocationKind::Elf(110),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_CALL36,
+                    },
                     0,
                 ) => RelocationKind::LArchCall36,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA_HI20),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA_HI20,
+                    },
                     0,
                 ) => RelocationKind::LArchPCAlaHi20,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA_LO12),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA_LO12,
+                    },
                     0,
                 ) => RelocationKind::LArchPCAlaLo12,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA64_HI12),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA64_HI12,
+                    },
                     0,
                 ) => RelocationKind::LArchPCAla64Hi12,
                 (
                     object::Architecture::LoongArch64,
-                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA64_LO20),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_LARCH_PCALA64_LO20,
+                    },
                     0,
                 ) => RelocationKind::LArchPCAla64Lo20,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_LO21),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADR_PREL_LO21,
+                    },
                     0,
                 ) => RelocationKind::Aarch64AdrPrelLo21,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_PG_HI21),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADR_PREL_PG_HI21,
+                    },
                     0,
                 ) => RelocationKind::Aarch64AdrPrelPgHi21,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_LDST128_ABS_LO12_NC),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_LDST128_ABS_LO12_NC,
+                    },
                     0,
                 ) => RelocationKind::Aarch64Ldst128AbsLo12Nc,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADD_ABS_LO12_NC),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_ADD_ABS_LO12_NC,
+                    },
                     0,
                 ) => RelocationKind::Aarch64AddAbsLo12Nc,
                 (
                     object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_LDST64_ABS_LO12_NC),
+                    object::RelocationFlags::Elf {
+                        r_type: object::elf::R_AARCH64_LDST64_ABS_LO12_NC,
+                    },
                     0,
                 ) => RelocationKind::Aarch64Ldst64AbsLo12Nc,
-                (object::Architecture::Aarch64, object::RelocationKind::MachO { value, .. }, _) => {
-                    match value {
-                        object::macho::ARM64_RELOC_UNSIGNED => {
-                            RelocationKind::MachoArm64RelocUnsigned
-                        }
-                        object::macho::ARM64_RELOC_SUBTRACTOR => {
-                            RelocationKind::MachoArm64RelocSubtractor
-                        }
-                        object::macho::ARM64_RELOC_BRANCH26 => {
-                            RelocationKind::MachoArm64RelocBranch26
-                        }
-                        object::macho::ARM64_RELOC_PAGE21 => RelocationKind::MachoArm64RelocPage21,
-                        object::macho::ARM64_RELOC_PAGEOFF12 => {
-                            RelocationKind::MachoArm64RelocPageoff12
-                        }
-                        object::macho::ARM64_RELOC_GOT_LOAD_PAGE21 => {
-                            RelocationKind::MachoArm64RelocGotLoadPage21
-                        }
-                        object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12 => {
-                            RelocationKind::MachoArm64RelocGotLoadPageoff12
-                        }
-                        object::macho::ARM64_RELOC_POINTER_TO_GOT => {
-                            RelocationKind::MachoArm64RelocPointerToGot
-                        }
-                        object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21 => {
-                            RelocationKind::MachoArm64RelocTlvpLoadPage21
-                        }
-                        object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12 => {
-                            RelocationKind::MachoArm64RelocTlvpLoadPageoff12
-                        }
-                        object::macho::ARM64_RELOC_ADDEND => RelocationKind::MachoArm64RelocAddend,
-                        _ => {
-                            return Err(CompileError::Codegen(format!(
-                                "unknown relocation {reloc:?}",
-                            )))
-                        }
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationFlags::MachO { r_type: value, .. },
+                    _,
+                ) => match value {
+                    object::macho::ARM64_RELOC_UNSIGNED => RelocationKind::MachoArm64RelocUnsigned,
+                    object::macho::ARM64_RELOC_SUBTRACTOR => {
+                        RelocationKind::MachoArm64RelocSubtractor
                     }
-                }
-                (object::Architecture::X86_64, object::RelocationKind::MachO { value, .. }, _) => {
-                    match value {
-                        object::macho::X86_64_RELOC_UNSIGNED => {
-                            RelocationKind::MachoX86_64RelocUnsigned
-                        }
-                        object::macho::X86_64_RELOC_SIGNED => {
-                            RelocationKind::MachoX86_64RelocSigned
-                        }
-                        object::macho::X86_64_RELOC_BRANCH => {
-                            RelocationKind::MachoX86_64RelocBranch
-                        }
-                        object::macho::X86_64_RELOC_GOT_LOAD => {
-                            RelocationKind::MachoX86_64RelocGotLoad
-                        }
-                        object::macho::X86_64_RELOC_GOT => RelocationKind::MachoX86_64RelocGot,
-                        object::macho::X86_64_RELOC_SUBTRACTOR => {
-                            RelocationKind::MachoX86_64RelocSubtractor
-                        }
-                        object::macho::X86_64_RELOC_SIGNED_1 => {
-                            RelocationKind::MachoX86_64RelocSigned1
-                        }
-                        object::macho::X86_64_RELOC_SIGNED_2 => {
-                            RelocationKind::MachoX86_64RelocSigned2
-                        }
-                        object::macho::X86_64_RELOC_SIGNED_4 => {
-                            RelocationKind::MachoX86_64RelocSigned4
-                        }
-                        object::macho::X86_64_RELOC_TLV => RelocationKind::MachoX86_64RelocTlv,
-                        _ => {
-                            return Err(CompileError::Codegen(format!(
-                                "unknown relocation {reloc:?}"
-                            )))
-                        }
+                    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:?}",
@@ -612,6 +673,20 @@ where
         })
         .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 mut custom_sections = section_to_custom_section
         .iter()
         .map(|(elf_section_index, custom_section_index)| {
@@ -671,5 +746,6 @@ where
         custom_sections,
         eh_frame_section_indices,
         compact_unwind_section_indices,
+        gcc_except_table_section_indices,
     })
 }
diff --git a/lib/compiler-llvm/src/trampoline/wasm.rs b/lib/compiler-llvm/src/trampoline/wasm.rs
index e9a95f3a3d..3d976494c2 100644
--- a/lib/compiler-llvm/src/trampoline/wasm.rs
+++ b/lib/compiler-llvm/src/trampoline/wasm.rs
@@ -1,11 +1,15 @@
+// TODO: Remove
+#![allow(unused)]
+
 use crate::{
-    abi::{get_abi, Abi, G0M0FunctionKind},
-    config::{CompiledKind, LLVM},
+    abi::{Abi, G0M0FunctionKind, get_abi},
+    config::LLVM,
     error::{err, err_nt},
-    object_file::{load_object_file, CompiledFunction},
-    translator::intrinsics::{type_to_llvm, type_to_llvm_ptr, Intrinsics},
+    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},
@@ -13,14 +17,21 @@ use inkwell::{
     targets::{FileType, TargetMachine},
     types::FunctionType,
     values::{BasicMetadataValueEnum, FunctionValue},
-    AddressSpace, DLLStorageClass,
 };
 use std::{cmp, convert::TryInto};
 use target_lexicon::BinaryFormat;
-use wasmer_compiler::types::{
-    function::FunctionBody, module::CompileModuleInfo, relocation::RelocationTarget,
+use wasmer_compiler::{
+    misc::CompiledKind,
+    types::{
+        function::FunctionBody,
+        module::CompileModuleInfo,
+        relocation::{Relocation, RelocationTarget},
+        section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
+    },
+};
+use wasmer_types::{
+    CompileError, FunctionIndex, FunctionType as FuncType, LocalFunctionIndex, entity::PrimaryMap,
 };
-use wasmer_types::{CompileError, FunctionType as FuncType, LocalFunctionIndex};
 use wasmer_vm::MemoryStyle;
 
 pub struct FuncTrampoline {
@@ -50,7 +61,7 @@ impl FuncTrampoline {
                 _ => {
                     return Err(CompileError::UnsupportedTarget(format!(
                         "Unsupported binary format: {binary_fmt:?}",
-                    )))
+                    )));
                 }
             },
             binary_fmt,
@@ -63,7 +74,7 @@ impl FuncTrampoline {
         config: &LLVM,
         name: &str,
         compile_info: &CompileModuleInfo,
-    ) -> Result<Module, CompileError> {
+    ) -> Result<Module<'_>, CompileError> {
         // The function type, used for the callbacks.
         let function = CompiledKind::FunctionCallTrampoline(ty.clone());
         let module = self.ctx.create_module("");
@@ -172,6 +183,19 @@ impl FuncTrampoline {
         }
 
         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,
@@ -181,7 +205,7 @@ impl FuncTrampoline {
         } = load_object_file(
             mem_buf_slice,
             &self.func_section,
-            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            dummy_reloc_target,
             |name: &str| {
                 Err(CompileError::Codegen(format!(
                     "trampoline generation produced reference to unknown function {name}",
@@ -226,7 +250,7 @@ impl FuncTrampoline {
         ty: &FuncType,
         config: &LLVM,
         name: &str,
-    ) -> Result<Module, CompileError> {
+    ) -> Result<Module<'_>, CompileError> {
         // The function type, used for the callbacks
         let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
         let module = self.ctx.create_module("");
@@ -241,6 +265,8 @@ impl FuncTrampoline {
             self.abi
                 .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);
         }
@@ -280,11 +306,19 @@ impl FuncTrampoline {
 
         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>,
     ) -> Result<FunctionBody, CompileError> {
         let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
         let target_machine = &self.target_machine;
@@ -308,12 +342,12 @@ impl FuncTrampoline {
             compiled_function,
             custom_sections,
             eh_frame_section_indices,
-            mut compact_unwind_section_indices,
-            ..
+            compact_unwind_section_indices,
+            gcc_except_table_section_indices,
         } = load_object_file(
             mem_buf_slice,
             &self.func_section,
-            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            RelocationTarget::DynamicTrampoline(FunctionIndex::from_u32(dynamic_trampoline_index)),
             |name: &str| {
                 Err(CompileError::Codegen(format!(
                     "trampoline generation produced reference to unknown function {name}",
@@ -321,26 +355,7 @@ impl FuncTrampoline {
             },
             self.binary_fmt,
         )?;
-        let mut all_sections_are_eh_sections = true;
-        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 {
-            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;
-                }
-            }
-        }
-        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(),
@@ -348,6 +363,65 @@ 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) {
+                    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,
@@ -380,7 +454,7 @@ impl FuncTrampoline {
                 _ => {
                     return Err(CompileError::Codegen(
                         "trampoline function unimplemented".to_string(),
-                    ))
+                    ));
                 }
             };
 
@@ -431,10 +505,8 @@ impl FuncTrampoline {
                 let global_ptr_ptr =
                     err!(builder.build_bit_cast(global_ptr_ptr, intrinsics.ptr_ty, ""))
                         .into_pointer_value();
-                let global_ptr = err!(builder.build_load(intrinsics.ptr_ty, global_ptr_ptr, ""))
-                    .into_pointer_value();
 
-                global_ptr
+                err!(builder.build_load(intrinsics.ptr_ty, global_ptr_ptr, "")).into_pointer_value()
             };
 
             let global_ptr = err!(builder.build_bit_cast(
@@ -483,11 +555,9 @@ impl FuncTrampoline {
                 let memory_definition_ptr_ptr =
                     err!(builder.build_bit_cast(memory_definition_ptr_ptr, intrinsics.ptr_ty, "",))
                         .into_pointer_value();
-                let memory_definition_ptr =
-                    err!(builder.build_load(intrinsics.ptr_ty, memory_definition_ptr_ptr, ""))
-                        .into_pointer_value();
 
-                memory_definition_ptr
+                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, "",))
@@ -503,10 +573,7 @@ impl FuncTrampoline {
             let base_ptr = if let MemoryStyle::Dynamic { .. } = memory_style {
                 base_ptr
             } else {
-                let base_ptr =
-                    err!(builder.build_load(intrinsics.ptr_ty, base_ptr, "")).into_pointer_value();
-
-                base_ptr
+                err!(builder.build_load(intrinsics.ptr_ty, base_ptr, "")).into_pointer_value()
             };
 
             base_ptr.set_name("trmpl_m0_base_ptr");
@@ -609,12 +676,14 @@ impl FuncTrampoline {
                 ""
             ))
             .into_pointer_value();
-            err!(builder.build_store(
-                ptr,
-                trampoline_func
-                    .get_nth_param(i as u32 + first_user_param)
-                    .unwrap(),
-            ));
+            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(
diff --git a/lib/compiler-llvm/src/translator/code.rs b/lib/compiler-llvm/src/translator/code.rs
index 6991054b0c..99af165e35 100644
--- a/lib/compiler-llvm/src/translator/code.rs
+++ b/lib/compiler-llvm/src/translator/code.rs
@@ -2,12 +2,13 @@ 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, TagCatchInfo},
 };
 use inkwell::{
+    AddressSpace, AtomicOrdering, AtomicRMWBinOp, DLLStorageClass, FloatPredicate, IntPredicate,
     attributes::AttributeLoc,
     builder::Builder,
     context::Context,
@@ -16,37 +17,37 @@ use inkwell::{
     targets::{FileType, TargetMachine},
     types::{BasicType, BasicTypeEnum, FloatMathType, IntType, PointerType, VectorType},
     values::{
-        AnyValue, BasicMetadataValueEnum, BasicValue, BasicValueEnum, CallSiteValue, FloatValue,
+        BasicMetadataValueEnum, BasicValue, BasicValueEnum, CallSiteValue, FloatValue,
         FunctionValue, InstructionOpcode, InstructionValue, IntValue, PhiValue, PointerValue,
         VectorValue,
     },
-    AddressSpace, AtomicOrdering, AtomicRMWBinOp, DLLStorageClass, FloatPredicate, IntPredicate,
 };
 use itertools::Itertools;
 use smallvec::SmallVec;
-use target_lexicon::BinaryFormat;
+use target_lexicon::{BinaryFormat, OperatingSystem, Triple};
 
 use crate::{
-    abi::{get_abi, Abi, G0M0FunctionKind, LocalFunctionG0M0params},
-    config::{CompiledKind, LLVM},
+    abi::{Abi, G0M0FunctionKind, LocalFunctionG0M0params, get_abi},
+    config::LLVM,
     error::{err, err_nt},
-    object_file::{load_object_file, CompiledFunction},
+    object_file::{CompiledFunction, load_object_file},
 };
 use wasmer_compiler::{
-    from_binaryreadererror_wasmerror,
+    FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader, ModuleMiddlewareChain,
+    ModuleTranslationState, from_binaryreadererror_wasmerror,
+    misc::CompiledKind,
     types::{
         relocation::RelocationTarget,
         symbols::{Symbol, SymbolRegistry},
     },
     wasmparser::{Catch, MemArg, Operator},
-    wpheaptype_to_type, wptype_to_type, FunctionBinaryReader, FunctionBodyData,
-    MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
+    wpheaptype_to_type, wptype_to_type,
 };
-use wasmer_types::{entity::PrimaryMap, TagIndex};
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex,
     ModuleInfo, SignatureIndex, TableIndex, Type,
 };
+use wasmer_types::{TagIndex, entity::PrimaryMap};
 use wasmer_vm::{MemoryStyle, TableStyle, VMOffsets};
 
 const FUNCTION_SECTION_ELF: &str = "__TEXT,wasmer_function";
@@ -84,7 +85,7 @@ impl FuncTranslator {
                 _ => {
                     return Err(CompileError::UnsupportedTarget(format!(
                         "Unsupported binary format: {binary_fmt:?}"
-                    )))
+                    )));
                 }
             },
             binary_fmt,
@@ -102,10 +103,12 @@ 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));
 
@@ -148,7 +151,10 @@ impl FuncTranslator {
             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);
 
@@ -161,7 +167,7 @@ impl FuncTranslator {
                 return Err(CompileError::UnsupportedTarget(format!(
                     "Unsupported binary format: {:?}",
                     self.binary_fmt
-                )))
+                )));
             }
         };
 
@@ -209,11 +215,7 @@ impl FuncTranslator {
         let mut params = vec![];
         let first_param =
             if func_type.get_return_type().is_none() && wasm_fn_type.results().len() > 1 {
-                if g0m0_is_enabled {
-                    4
-                } else {
-                    2
-                }
+                if g0m0_is_enabled { 4 } else { 2 }
             } else if g0m0_is_enabled {
                 3
             } else {
@@ -305,8 +307,6 @@ impl FuncTranslator {
             symbol_registry,
             abi: &*self.abi,
             config,
-            exception_types_cache: HashMap::new(),
-            vmctx_alloca: None,
             tags_cache: HashMap::new(),
             binary_fmt: self.binary_fmt,
         };
@@ -408,6 +408,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,
@@ -418,8 +419,12 @@ impl FuncTranslator {
             memory_styles,
             table_styles,
             symbol_registry,
+            target,
         )?;
-        let function = CompiledKind::Local(*local_func_index);
+        let function = CompiledKind::Local(
+            *local_func_index,
+            wasm_module.get_function_name(wasm_module.func_index(*local_func_index)),
+        );
         let target_machine = &self.target_machine;
         let memory_buffer = target_machine
             .write_to_memory_buffer(&module, FileType::Object)
@@ -473,20 +478,22 @@ impl<'ctx> LLVMFunctionCodeGenerator<'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.
-        err_nt!(self.builder.build_shuffle_vector(
-            err!(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(),
-            "",
-        ))
+            )
+        )
     }
 
     // Convert floating point vector to integer and saturate when out of range.
@@ -565,9 +572,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         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"));
+            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,
@@ -586,9 +594,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             "not_representable_as_int",
         ));
         let value =
-            err!(self
-                .builder
-                .build_select(not_representable, zero, value, "safe_to_convert"))
+            err!(
+                self.builder
+                    .build_select(not_representable, zero, value, "safe_to_convert")
+            )
             .into_vector_value();
         let value = if is_signed {
             self.builder
@@ -600,14 +609,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
         let value = err!(value);
         let value =
-            err!(self
-                .builder
-                .build_select(above_upper_bound_cmp, int_max_value, value, ""))
+            err!(
+                self.builder
+                    .build_select(above_upper_bound_cmp, int_max_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()))
+        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.
@@ -632,10 +643,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             int_max_value,
             value,
         )?;
-        err_nt!(self
-            .builder
-            .build_bit_cast(res, self.intrinsics.i128_ty, "")
-            .map(|v| v.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.
@@ -698,9 +710,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         let zero = value.get_type().const_zero();
 
         let nan_cmp =
-            err!(self
-                .builder
-                .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+            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,
@@ -719,34 +732,40 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             "not_representable_as_int",
         ));
         let value =
-            err!(self
-                .builder
-                .build_select(not_representable, zero, value, "safe_to_convert"))
+            err!(
+                self.builder
+                    .build_select(not_representable, zero, value, "safe_to_convert")
+            )
             .into_float_value();
         let value = if is_signed {
-            err!(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 {
-            err!(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 =
-            err!(self
-                .builder
-                .build_select(above_upper_bound_cmp, int_max_value, value, ""))
+            err!(
+                self.builder
+                    .build_select(above_upper_bound_cmp, int_max_value, value, "")
+            )
             .into_int_value();
         let value =
-            err!(self
-                .builder
-                .build_select(below_lower_bound_cmp, int_min_value, value, ""))
+            err!(
+                self.builder
+                    .build_select(below_lower_bound_cmp, int_min_value, value, "")
+            )
             .into_int_value();
 
-        err_nt!(self
-            .builder
-            .build_bit_cast(value, int_ty, "")
-            .map(|v| v.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(
@@ -762,16 +781,18 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             self.intrinsics.i64_ty
         };
 
-        let lower_bound =
-            err!(self
-                .builder
-                .build_bit_cast(int_ty.const_int(lower_bound, false), float_ty, ""))
-            .into_float_value();
-        let upper_bound =
-            err!(self
-                .builder
-                .build_bit_cast(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
@@ -801,23 +822,26 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             .context
             .append_basic_block(self.function, "conversion_success_block");
 
-        err!(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 =
-            err!(self
-                .builder
-                .build_float_compare(FloatPredicate::UNO, value, value, "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,
             "",
         ));
-        err!(self
-            .builder
-            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw"));
+        err!(
+            self.builder
+                .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw")
+        );
         err!(self.builder.build_unreachable());
         self.builder.position_at_end(continue_block);
 
@@ -878,8 +902,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             "should_trap_expect",
         ))
         .try_as_basic_value()
-        .left()
-        .unwrap()
+        .unwrap_basic()
         .into_int_value();
 
         let shouldnt_trap_block = self
@@ -900,9 +923,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             self.intrinsics.trap_illegal_arithmetic,
             "",
         ));
-        err!(self
-            .builder
-            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw"));
+        err!(
+            self.builder
+                .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw")
+        );
         err!(self.builder.build_unreachable());
         self.builder.position_at_end(shouldnt_trap_block);
 
@@ -927,8 +951,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             "should_trap_expect",
         ))
         .try_as_basic_value()
-        .left()
-        .unwrap()
+        .unwrap_basic()
         .into_int_value();
 
         let shouldnt_trap_block = self
@@ -960,16 +983,22 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         info: ExtraInfo,
         int_vec_ty: VectorType<'ctx>,
     ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
-        let (value, info) = 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())
+        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)
         };
@@ -1018,18 +1047,21 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
     ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
-        let (value, info) = if info.has_pending_f64_nan() {
-            let value = err!(self
-                .builder
-                .build_bit_cast(value, self.intrinsics.f64x2_ty, ""));
+        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)
         };
         Ok((
-            err!(self
-                .builder
-                .build_bit_cast(value, self.intrinsics.f32x4_ty, ""))
+            err!(
+                self.builder
+                    .build_bit_cast(value, self.intrinsics.f32x4_ty, "")
+            )
             .into_vector_value(),
             info,
         ))
@@ -1042,18 +1074,21 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
     ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
-        let (value, info) = if info.has_pending_f32_nan() {
-            let value = err!(self
-                .builder
-                .build_bit_cast(value, self.intrinsics.f32x4_ty, ""));
+        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)
         };
         Ok((
-            err!(self
-                .builder
-                .build_bit_cast(value, self.intrinsics.f64x2_ty, ""))
+            err!(
+                self.builder
+                    .build_bit_cast(value, self.intrinsics.f64x2_ty, "")
+            )
             .into_vector_value(),
             info,
         ))
@@ -1073,9 +1108,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
             {
                 let ty = value.get_type();
-                let value = err!(self
-                    .builder
-                    .build_bit_cast(value, self.intrinsics.f32x4_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 {
@@ -1086,9 +1122,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
             {
                 let ty = value.get_type();
-                let value = err!(self
-                    .builder
-                    .build_bit_cast(value, self.intrinsics.f64x2_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 {
@@ -1114,74 +1151,35 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             let f_ty = f_ty.into_vector_type();
             let zero = f_ty.const_zero();
             let nan_cmp =
-                err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+                err!(
+                    self.builder
+                        .build_float_compare(FloatPredicate::UNO, value, zero, "nan")
+                );
             let canonical_qnan = f_ty
                 .get_element_type()
                 .into_float_type()
                 .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()))
+            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 =
-                err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+                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()))
-        }
-    }
-
-    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().left().unwrap())),
-            None => Ok(value),
+            err_nt!(
+                self.builder
+                    .build_select(nan_cmp, canonical_qnan, value, "")
+                    .map(|v| v.as_basic_value_enum())
+            )
         }
     }
 
@@ -1265,13 +1263,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     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
                         }
@@ -1332,8 +1329,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                             "ptr_in_bounds_expect",
                         ))
                         .try_as_basic_value()
-                        .left()
-                        .unwrap()
+                        .unwrap_basic()
                         .into_int_value();
 
                         let in_bounds_continue_block =
@@ -1371,9 +1367,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         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()))
+        err_nt!(
+            builder
+                .build_bit_cast(value_ptr, ptr_ty, "mem_value")
+                .map(|v| v.into_pointer_value())
+        )
     }
 
     fn trap_if_misaligned(
@@ -1385,10 +1383,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         if align <= 1 {
             return Ok(());
         }
-        let value =
-            err!(self
-                .builder
-                .build_ptr_to_int(ptr, self.intrinsics.i64_ty, "mischeck_value"));
+        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),
@@ -1409,8 +1408,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             "is_aligned_expect",
         ))
         .try_as_basic_value()
-        .left()
-        .unwrap()
+        .unwrap_basic()
         .into_int_value();
 
         let continue_block = self
@@ -1419,9 +1417,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         let not_aligned_block = self
             .context
             .append_basic_block(self.function, "misaligned_trap_block");
-        err!(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);
         err!(self.builder.build_call(
@@ -1439,10 +1438,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         let func_type = self.function.get_type();
 
         let results = self.state.popn_save_extra(wasm_fn_type.results().len())?;
-        let results = err!(results
-            .into_iter()
-            .map(|(v, i)| self.apply_pending_canonicalization(v, i))
-            .collect::<Result<Vec<_>, _>>());
+        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() {
             err!(self.builder.build_return(None));
@@ -1468,22 +1469,24 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ));
                 struct_value =
-                    err!(self
-                        .builder
-                        .build_insert_value(struct_value, value, idx as u32, ""))
+                    err!(
+                        self.builder
+                            .build_insert_value(struct_value, value, idx as u32, "")
+                    )
                     .into_struct_value();
             }
             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,
-                )?)));
+            err!(
+                self.builder
+                    .build_return(Some(&self.abi.pack_values_for_register_return(
+                        self.intrinsics,
+                        &self.builder,
+                        &results,
+                        &func_type,
+                    )?))
+            );
         }
         Ok(())
     }
@@ -1528,25 +1531,6 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
         tag_glbl
     }
 
-    fn get_or_insert_exception_type(
-        &mut self,
-        tag: u32,
-        signature: &FunctionType,
-    ) -> Result<inkwell::types::StructType<'ctx>, CompileError> {
-        if let Some(ty) = self.exception_types_cache.get(&tag) {
-            return Ok(*ty);
-        }
-        let types = signature
-            .params()
-            .iter()
-            .map(|v| type_to_llvm(self.intrinsics, *v))
-            .collect::<Result<Vec<_>, CompileError>>()?;
-
-        let ty = self.context.struct_type(&types, false);
-        self.exception_types_cache.insert(tag, ty);
-        Ok(ty)
-    }
-
     fn build_g0m0_indirect_call(
         &mut self,
         table_index: u32,
@@ -1598,21 +1582,23 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
             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<_>>()
-            ));
+            err!(
+                self.builder.build_switch(
+                    func_index,
+                    unreachable_indirect_call_branch_block,
+                    &local_func_indices
+                        .into_iter()
+                        .map(|v| (
+                            self.intrinsics.i32_ty.const_int(v as _, false),
+                            local_idx_block
+                        ))
+                        .chain(foreign_func_indices.into_iter().map(|v| (
+                            self.intrinsics.i32_ty.const_int(v as _, false),
+                            foreign_idx_block
+                        )))
+                        .collect::<Vec<_>>()
+                )
+            );
 
             self.builder
                 .position_at_end(unreachable_indirect_call_branch_block);
@@ -1784,17 +1770,19 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             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",
-            ))
+            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);
@@ -1802,21 +1790,6 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
         Ok(call_site_local)
     }
-
-    fn build_or_get_vmctx_alloca(&mut self) -> Result<PointerValue<'ctx>, CompileError> {
-        if let Some(vmctx_alloca) = self.vmctx_alloca {
-            return Ok(vmctx_alloca);
-        }
-
-        let vmctx_alloca = err!(self
-            .alloca_builder
-            .build_alloca(self.intrinsics.ptr_ty, "vmctx"));
-        err!(self
-            .alloca_builder
-            .build_store(vmctx_alloca, self.ctx.basic()));
-        self.vmctx_alloca = Some(vmctx_alloca);
-        Ok(vmctx_alloca)
-    }
 }
 
 /*
@@ -1932,12 +1905,131 @@ pub struct LLVMFunctionCodeGenerator<'ctx, 'a> {
     abi: &'a dyn Abi,
     config: &'a LLVM,
     tags_cache: HashMap<i32, BasicValueEnum<'ctx>>,
-    exception_types_cache: HashMap<u32, inkwell::types::StructType<'ctx>>,
-    vmctx_alloca: Option<PointerValue<'ctx>>,
     binary_fmt: target_lexicon::BinaryFormat,
 }
 
 impl<'ctx> 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 = 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 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 = 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 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 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.
@@ -2427,9 +2519,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 } else {
                     Default::default()
                 };
-                let f = err!(self
-                    .builder
-                    .build_bit_cast(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 } => {
@@ -2439,9 +2532,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 } else {
                     Default::default()
                 };
-                let f = err!(self
-                    .builder
-                    .build_bit_cast(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 } => {
@@ -2479,49 +2573,56 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::I8x16Splat => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = v.into_int_value();
-                let v = err!(self
-                    .builder
-                    .build_int_truncate(v, self.intrinsics.i8_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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_truncate(v, self.intrinsics.i16_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, ""));
+                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 = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_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 = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_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 = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_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);
@@ -2529,9 +2630,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::F64x2Splat => {
                 let (v, i) = self.state.pop1_extra()?;
                 let res = self.splat_vector(v, self.intrinsics.f64x2_ty)?;
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_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);
@@ -2634,7 +2736,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                             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;
@@ -2809,17 +2911,19 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     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(),
-                        "",
-                    ))
+                    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);
@@ -2885,8 +2989,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "index_in_bounds_expect",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
+                .unwrap_basic()
                 .into_int_value();
 
                 let in_bounds_continue_block = self
@@ -2936,9 +3039,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
                 // trap if we're trying to call a null funcref
                 {
-                    let funcref_not_null = err!(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
@@ -2991,17 +3095,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     )
                     .unwrap();
                 let (func_ptr, found_dynamic_sigindex, ctx_ptr) = (
-                    err!(self
-                        .builder
-                        .build_load(self.intrinsics.ptr_ty, func_ptr_ptr, "func_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"))
+                    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")),
+                    err!(
+                        self.builder
+                            .build_load(self.intrinsics.ptr_ty, ctx_ptr_ptr, "ctx_ptr")
+                    ),
                 );
 
                 // Next, check if the table element is initialized.
@@ -3018,10 +3125,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "sigindices_equal",
                 ));
 
-                let initialized_and_sigindices_match =
-                    err!(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 = err!(self.builder.build_call(
@@ -3033,8 +3141,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "initialized_and_sigindices_match_expect",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
+                .unwrap_basic()
                 .into_int_value();
 
                 let continue_block = self
@@ -3105,9 +3212,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8Add => {
@@ -3115,9 +3223,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtAddPairwiseI8x16S | Operator::I16x8ExtAddPairwiseI8x16U => {
@@ -3167,9 +3276,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let right = err!(extend_op(self, right));
 
                 let res = err!(self.builder.build_int_add(left, right, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4Add => {
@@ -3177,9 +3287,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtAddPairwiseI16x8S | Operator::I32x4ExtAddPairwiseI16x8U => {
@@ -3221,9 +3332,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let right = err!(extend_op(self, right));
 
                 let res = err!(self.builder.build_int_add(left, right, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2Add => {
@@ -3231,9 +3343,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16AddSatS => {
@@ -3246,11 +3359,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3263,11 +3376,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3280,11 +3393,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3297,11 +3410,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3317,9 +3430,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8Sub => {
@@ -3327,9 +3441,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4Sub => {
@@ -3337,9 +3452,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2Sub => {
@@ -3347,9 +3463,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16SubSatS => {
@@ -3362,11 +3479,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3379,11 +3496,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3396,11 +3513,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3413,11 +3530,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -3433,9 +3550,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4Mul => {
@@ -3443,9 +3561,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2Mul => {
@@ -3453,9 +3572,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8Q15MulrSatS => {
@@ -3466,12 +3586,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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 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
@@ -3490,20 +3612,23 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                         self.intrinsics.i32x8_ty,
                         ""
                     ));
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, res, max_values, ""))
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SGT, res, max_values, "")
+                    )
                 };
 
-                let res = err!(self
-                    .builder
-                    .build_int_truncate(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_int_truncate(res, self.intrinsics.i16x8_ty, "")
+                );
 
                 let res = err!(self.builder.build_select(saturate_up, max_values, res, ""))
                     .into_vector_value();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtMulLowI8x16S
@@ -3564,9 +3689,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 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 res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtMulLowI16x8S
@@ -3615,9 +3741,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 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 res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2ExtMulLowI32x4S
@@ -3660,9 +3787,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 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 res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4DotI16x8S => {
@@ -3687,47 +3815,52 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     VectorType::const_vector(&low_i16),
                     "",
                 ));
-                let v1_low =
-                    err!(self
-                        .builder
-                        .build_int_s_extend(v1_low, self.intrinsics.i32x4_ty, ""));
+                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 =
-                    err!(self
-                        .builder
-                        .build_int_s_extend(v1_high, self.intrinsics.i32x4_ty, ""));
+                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 =
-                    err!(self
-                        .builder
-                        .build_int_s_extend(v2_low, self.intrinsics.i32x4_ty, ""));
+                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 =
-                    err!(self
-                        .builder
-                        .build_int_s_extend(v2_high, self.intrinsics.i32x4_ty, ""));
+                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 = err!(self.builder.build_int_add(low_product, high_product, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32DivS | Operator::I64DivS => {
@@ -3799,9 +3932,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "srem_will_overflow",
                 ));
                 let v1 =
-                    err!(self
-                        .builder
-                        .build_select(will_overflow, int_type.const_zero(), v1, ""))
+                    err!(
+                        self.builder
+                            .build_select(will_overflow, int_type.const_zero(), v1, "")
+                    )
                     .into_int_value();
                 let res = err!(self.builder.build_int_signed_rem(v1, v2, ""));
                 self.state.push1(res);
@@ -3855,22 +3989,26 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""))
+                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, ""))
+                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, ""))
+                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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16Bitmask => {
@@ -3878,14 +4016,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i8x16(v, i)?;
 
                 let zeros = self.intrinsics.i8x16_ty.const_zero();
-                let res = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                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 = err!(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 => {
@@ -3893,14 +4033,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i16x8(v, i)?;
 
                 let zeros = self.intrinsics.i16x8_ty.const_zero();
-                let res = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                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 = err!(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 => {
@@ -3908,14 +4050,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i32x4(v, i)?;
 
                 let zeros = self.intrinsics.i32x4_ty.const_zero();
-                let res = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                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 = err!(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 => {
@@ -3923,14 +4067,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i64x2(v, i)?;
 
                 let zeros = self.intrinsics.i64x2_ty.const_zero();
-                let res = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                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 = err!(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 => {
@@ -3958,17 +4104,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i8x16(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8Shl => {
@@ -3976,17 +4125,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i16x8(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4Shl => {
@@ -4001,9 +4153,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
                 let res = err!(self.builder.build_left_shift(v1, v2, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2Shl => {
@@ -4016,14 +4169,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.intrinsics.i32_ty.const_int(63, false),
                     ""
                 ));
-                let v2 = err!(self
-                    .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = err!(
+                    self.builder
+                        .build_int_z_extend(v2, self.intrinsics.i64_ty, "")
+                );
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
                 let res = err!(self.builder.build_left_shift(v1, v2, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32ShrS => {
@@ -4051,17 +4206,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i8x16(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ShrS => {
@@ -4069,17 +4227,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i16x8(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ShrS => {
@@ -4094,9 +4255,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
                 let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2ShrS => {
@@ -4109,14 +4271,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.intrinsics.i32_ty.const_int(63, false),
                     ""
                 ));
-                let v2 = err!(self
-                    .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = err!(
+                    self.builder
+                        .build_int_z_extend(v2, self.intrinsics.i64_ty, "")
+                );
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
                 let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32ShrU => {
@@ -4144,17 +4308,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i8x16(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ShrU => {
@@ -4162,17 +4329,20 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v1, _) = self.v128_into_i16x8(v1, i1)?;
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ShrU => {
@@ -4187,9 +4357,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 ));
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
                 let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2ShrU => {
@@ -4202,14 +4373,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.intrinsics.i32_ty.const_int(63, false),
                     ""
                 ));
-                let v2 = err!(self
-                    .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = err!(
+                    self.builder
+                        .build_int_z_extend(v2, self.intrinsics.i64_ty, "")
+                );
                 let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
                 let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32Rotl => {
@@ -4286,8 +4459,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Clz => {
@@ -4300,8 +4472,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I32Ctz => {
@@ -4314,8 +4485,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Ctz => {
@@ -4328,47 +4498,47 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .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 res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ctpop_i8x16, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ctpop_i8x16,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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 res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ctpop_i32, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ctpop_i32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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 res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ctpop_i64, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ctpop_i64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I32Eqz => {
@@ -4379,9 +4549,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.intrinsics.i32_zero,
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(cond, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Eqz => {
@@ -4392,9 +4563,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.intrinsics.i64_zero,
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_int_z_extend(cond, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I8x16Abs => {
@@ -4406,9 +4578,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8Abs => {
@@ -4420,9 +4593,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4Abs => {
@@ -4434,9 +4608,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2Abs => {
@@ -4448,165 +4623,190 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                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, ""));
+                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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16AvgrU => {
@@ -4636,12 +4836,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ));
                 let res = err!(self.builder.build_right_shift(res, one, false, ""));
-                let res = err!(self
-                    .builder
-                    .build_int_truncate(res, self.intrinsics.i8x16_ty, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .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 => {
@@ -4671,12 +4873,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ));
                 let res = err!(self.builder.build_right_shift(res, one, false, ""));
-                let res = err!(self
-                    .builder
-                    .build_int_truncate(res, self.intrinsics.i16x8_ty, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .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);
             }
 
@@ -4697,8 +4901,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
@@ -4718,8 +4921,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
@@ -4740,11 +4942,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4765,11 +4967,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4789,8 +4991,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
@@ -4810,8 +5011,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
@@ -4832,11 +5032,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4857,11 +5057,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4881,8 +5081,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
@@ -4902,8 +5101,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(
                     res,
                     ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
@@ -4924,11 +5122,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4949,11 +5147,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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())?,
@@ -4973,8 +5171,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64Div => {
@@ -4991,8 +5188,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4Div => {
@@ -5010,11 +5206,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 => {
@@ -5032,1229 +5228,555 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.sqrt_f32, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sqrt_f32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64Sqrt => {
                 let input = self.state.pop1()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.sqrt_f64, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sqrt_f64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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 res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.sqrt_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let bits = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, "bits"));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sqrt_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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 res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.sqrt_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let bits = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, "bits"));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sqrt_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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 ((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 v1_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f32_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f32_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.minimum_f32,
+                    &[lhs.into(), rhs.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1)?,
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2)?,
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v1,
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v2,
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_or(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i32_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i32_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f32_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        )),
-                        "",
-                    )),
-                    "",
-                ));
+                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::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 ((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 v1_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f64_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f64_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.minimum_f64,
+                    &[lhs.into(), rhs.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1)?,
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2)?,
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v1,
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v2,
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_or(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i64_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i64_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f64_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        )),
-                        "",
-                    )),
-                    "",
-                ));
+                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::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 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f32x4_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f32x4_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.minimum_f32x4,
+                    &[v1.into(), v2.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1.into())?.into_vector_value(),
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2.into())?.into_vector_value(),
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v1.into(),
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v2.into(),
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_or(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i32x4_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i32x4_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f32x4_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        ))
-                        .into_vector_value(),
-                        "",
-                    ))
-                    .into_vector_value(),
-                    "",
-                ));
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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::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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v2, v1, ""));
+                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, ""));
+                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 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f64x2_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f64x2_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.minimum_f64x2,
+                    &[v1.into(), v2.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1.into())?.into_vector_value(),
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2.into())?.into_vector_value(),
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v1.into(),
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v2.into(),
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_or(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i64x2_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i64x2_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f64x2_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        ))
-                        .into_vector_value(),
-                        "",
-                    ))
-                    .into_vector_value(),
-                    "",
-                ));
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v2, v1, ""));
+                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, ""));
+                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 ((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 v1_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f32_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f32_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.maximum_f32,
+                    &[lhs.into(), rhs.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1)?,
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2)?,
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v2,
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v1,
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_and(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i32_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i32_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f32_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        )),
-                        "",
-                    )),
-                    "",
-                ));
+                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 ((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 v1_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f64_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f64_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.maximum_f64,
+                    &[lhs.into(), rhs.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_int_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1)?,
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2)?,
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v2,
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v1,
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_and(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i64_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i64_ty,
-                                            ""
-                                        ))
-                                        .into_int_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f64_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        )),
-                        "",
-                    )),
-                    "",
-                ));
+                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 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f32x4_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f32x4_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f32x4,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.maximum_f32x4,
+                    &[v1.into(), v2.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1.into())?.into_vector_value(),
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2.into())?.into_vector_value(),
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v2.into(),
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v1.into(),
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_and(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i32x4_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i32x4_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f32x4_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        ))
-                        .into_vector_value(),
-                        "",
-                    ))
-                    .into_vector_value(),
-                    "",
-                ));
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(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 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        self.intrinsics.f64x2_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v2_is_nan = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v2.into(),
-                        self.intrinsics.f64x2_zero.into(),
-                        self.intrinsics.fp_uno_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_lt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_olt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
-                    "",
-                ))
-                .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
-                let v1_gt_v2 = err!(self.builder.build_call(
-                    self.intrinsics.cmp_f64x2,
-                    &[
-                        v1.into(),
-                        v2.into(),
-                        self.intrinsics.fp_ogt_md,
-                        self.intrinsics.fp_exception_md,
-                    ],
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.maximum_f64x2,
+                    &[v1.into(), v2.into()],
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap()
-                .into_vector_value();
+                .unwrap_basic();
 
-                let res = err!(self.builder.build_select(
-                    v1_is_nan,
-                    self.quiet_nan(v1.into())?.into_vector_value(),
-                    err!(self.builder.build_select(
-                        v2_is_nan,
-                        self.quiet_nan(v2.into())?.into_vector_value(),
-                        err!(self.builder.build_select(
-                            v1_lt_v2,
-                            v2.into(),
-                            err!(self.builder.build_select(
-                                v1_gt_v2,
-                                v1.into(),
-                                err!(self.builder.build_bit_cast(
-                                    err!(self.builder.build_and(
-                                        err!(self.builder.build_bit_cast(
-                                            v1,
-                                            self.intrinsics.i64x2_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        err!(self.builder.build_bit_cast(
-                                            v2,
-                                            self.intrinsics.i64x2_ty,
-                                            "",
-                                        ))
-                                        .into_vector_value(),
-                                        "",
-                                    )),
-                                    self.intrinsics.f64x2_ty,
-                                    "",
-                                )),
-                                "",
-                            )),
-                            "",
-                        ))
-                        .into_vector_value(),
-                        "",
-                    ))
-                    .into_vector_value(),
-                    "",
-                ));
+                let res = self.finalize_minmax_result(res.as_basic_value_enum())?;
+                let res = res.into_vector_value();
 
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                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, ""));
+                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 =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ceil_f32, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ceil_f32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (info | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Ceil => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ceil_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ceil_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Ceil => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ceil_f64, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ceil_f64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (info | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Ceil => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f64x2(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.ceil_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ceil_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.floor_f32, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.floor_f32,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (info | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Floor => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f32x4(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.floor_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.floor_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.floor_f64, &[input.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.floor_f64,
+                    &[input.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (info | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Floor => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f64x2(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.floor_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.floor_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = err!(self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f32, &[v.into()], ""))
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.trunc_f32, &[v.into()], "")
+                )
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f32x4(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.trunc_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.trunc_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = err!(self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f64, &[v.into()], ""))
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.trunc_f64, &[v.into()], "")
+                )
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f64x2(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.trunc_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.trunc_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.nearbyint_f32, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.nearbyint_f32,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f32x4(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.nearbyint_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.nearbyint_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.nearbyint_f64, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.nearbyint_f64,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
                 let (v, _) = self.v128_into_f64x2(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.nearbyint_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.nearbyint_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .unwrap_basic();
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Abs => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = self.apply_pending_canonicalization(v, i)?;
-                let res = err!(self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f32, &[v.into()], ""))
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.fabs_f32, &[v.into()], "")
+                )
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 // The exact NaN returned by F32Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
@@ -6262,12 +5784,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::F64Abs => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = self.apply_pending_canonicalization(v, i)?;
-                let res = err!(self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f64, &[v.into()], ""))
+                let res = err!(
+                    self.builder
+                        .build_call(self.intrinsics.fabs_f64, &[v.into()], "")
+                )
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 // The exact NaN returned by F64Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
@@ -6280,16 +5802,17 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ));
                 let v = self.apply_pending_canonicalization(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.fabs_f32x4, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.fabs_f32x4,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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());
@@ -6302,16 +5825,17 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ));
                 let v = self.apply_pending_canonicalization(v, i)?;
-                let res =
-                    err!(self
-                        .builder
-                        .build_call(self.intrinsics.fabs_f64x2, &[v.into()], ""))
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.fabs_f64x2,
+                    &[v.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .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());
@@ -6327,9 +5851,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .apply_pending_canonicalization(v, i)?
                     .into_vector_value();
                 let res = err!(self.builder.build_float_neg(v, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                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());
@@ -6345,9 +5870,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .apply_pending_canonicalization(v, i)?
                     .into_vector_value();
                 let res = err!(self.builder.build_float_neg(v, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                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());
@@ -6372,8 +5898,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .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());
@@ -6388,8 +5913,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ""
                 ))
                 .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());
@@ -6405,9 +5929,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 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, ""));
+                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())?,
@@ -6418,12 +5943,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6431,12 +5958,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6444,12 +5973,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6457,12 +5988,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6471,9 +6004,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 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, ""));
+                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())?,
@@ -6484,12 +6018,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6497,12 +6033,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6510,12 +6048,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6523,12 +6063,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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, ""));
+                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 => {
@@ -6536,12 +6078,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
-                let res = err!(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())?,
@@ -6551,60 +6095,72 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6612,57 +6168,68 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
-                let res = err!(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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6670,12 +6237,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
-                let res = err!(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())?,
@@ -6685,60 +6254,72 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6746,12 +6327,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, ""));
-                let res = err!(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())?,
@@ -6761,45 +6344,54 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6807,12 +6399,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
-                let res = err!(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())?,
@@ -6822,60 +6416,72 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6883,12 +6489,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
-                let res = err!(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())?,
@@ -6898,45 +6506,54 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -6944,72 +6561,86 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
-                let res = err!(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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 => {
@@ -7017,12 +6648,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self
-                    .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, ""));
-                let res = err!(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())?,
@@ -7032,45 +6665,54 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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);
             }
 
@@ -7081,12 +6723,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::F32Eq | Operator::F64Eq => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                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, ""));
+                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())?,
@@ -7096,41 +6740,49 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, ""));
-                let res = err!(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())?,
@@ -7140,41 +6792,49 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
-                let res = err!(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())?,
@@ -7184,41 +6844,49 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, ""));
-                let res = err!(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())?,
@@ -7228,41 +6896,49 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, ""));
-                let res = err!(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())?,
@@ -7272,41 +6948,49 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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 = err!(self
-                    .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, ""));
-                let res = err!(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())?,
@@ -7316,30 +7000,36 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = 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, ""));
+                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 = 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, ""));
+                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);
             }
 
@@ -7351,27 +7041,30 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, i) = self.state.pop1_extra()?;
                 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, ""));
+                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 = v.into_int_value();
-                let res = err!(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 = v.into_int_value();
-                let res = err!(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 => {
@@ -7392,12 +7085,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtendHighI8x16S => {
@@ -7418,12 +7113,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtendLowI8x16U => {
@@ -7444,12 +7141,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtendHighI8x16U => {
@@ -7470,12 +7169,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtendLowI16x8S => {
@@ -7492,12 +7193,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtendHighI16x8S => {
@@ -7514,12 +7217,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtendLowI16x8U => {
@@ -7536,12 +7241,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ExtendHighI16x8U => {
@@ -7558,12 +7265,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::I64x2ExtendLowI32x4U
@@ -7597,9 +7306,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ));
                 let res = err!(extend(self, low));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16NarrowI16x8S => {
@@ -7611,21 +7321,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let min = VectorType::const_vector(&[min; 8]);
                 let max = VectorType::const_vector(&[max; 8]);
                 let apply_min_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v1, min, "")
+                    );
                 let apply_max_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SGT, v1, max, "")
+                    );
                 let apply_min_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v2, min, "")
+                    );
                 let apply_max_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                    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 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
@@ -7667,9 +7381,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16NarrowI16x8U => {
@@ -7680,21 +7395,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let max = self.intrinsics.i16_ty.const_int(0x00ff, false);
                 let max = VectorType::const_vector(&[max; 8]);
                 let apply_min_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v1, min, "")
+                    );
                 let apply_max_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SGT, v1, max, "")
+                    );
                 let apply_min_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v2, min, "")
+                    );
                 let apply_max_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                    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 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
@@ -7736,9 +7455,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8NarrowI32x4S => {
@@ -7750,21 +7470,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let min = VectorType::const_vector(&[min; 4]);
                 let max = VectorType::const_vector(&[max; 4]);
                 let apply_min_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v1, min, "")
+                    );
                 let apply_max_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SGT, v1, max, "")
+                    );
                 let apply_min_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v2, min, "")
+                    );
                 let apply_max_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                    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 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
@@ -7798,9 +7522,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8NarrowI32x4U => {
@@ -7811,21 +7536,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let max = self.intrinsics.i32_ty.const_int(0xffff, false);
                 let max = VectorType::const_vector(&[max; 4]);
                 let apply_min_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v1, min, "")
+                    );
                 let apply_max_clamp_v1 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SGT, v1, max, "")
+                    );
                 let apply_min_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
+                    err!(
+                        self.builder
+                            .build_int_compare(IntPredicate::SLT, v2, min, "")
+                    );
                 let apply_max_clamp_v2 =
-                    err!(self
-                        .builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                    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 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
@@ -7859,9 +7588,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4TruncSatF32x4S => {
@@ -7932,9 +7662,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             // Operator::I64x2TruncSatF64x2S => {
@@ -7974,10 +7705,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x4effffff, // 2147483500.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -7987,10 +7719,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x41dfffffffffffff, // 2147483647.9999998
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8028,10 +7761,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x5effffff, // 9223371500000000000.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8041,10 +7775,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x43dfffffffffffff, // 9223372036854775000.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8082,10 +7817,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x4f7fffff, // 4294967000.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8095,10 +7831,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x41efffffffffffff, // 4294967295.9999995
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8136,10 +7873,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x5f7fffff, // 18446743000000000000.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8149,10 +7887,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0x43efffffffffffff, // 18446744073709550000.0
                     v1,
                 )?;
-                let res =
-                    err!(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 => {
@@ -8196,8 +7935,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64PromoteF32 => {
@@ -8209,74 +7947,81 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .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 = v.into_int_value();
-                let res =
-                    err!(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 = v.into_int_value();
-                let res =
-                    err!(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 = v.into_int_value();
-                let res =
-                    err!(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 = v.into_int_value();
-                let res =
-                    err!(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 = err!(self.builder.build_bit_cast(v, self.intrinsics.i32x4_ty, ""))
                     .into_vector_value();
-                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, ""));
+                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 = err!(self.builder.build_bit_cast(v, self.intrinsics.i32x4_ty, ""))
                     .into_vector_value();
-                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, ""));
+                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 => {
@@ -8301,13 +8046,15 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ));
                 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 = 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, "")
+                );
                 self.state.push1(res);
             }
             Operator::F64x2PromoteLowF32x4 => {
@@ -8322,12 +8069,14 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                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 = err!(
+                    self.builder
+                        .build_float_ext(low, self.intrinsics.f64x2_ty, "")
+                );
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4DemoteF64x2Zero => {
@@ -8347,9 +8096,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ]),
                     "",
                 ));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             // Operator::F64x2ConvertI64x2S => {
@@ -8405,62 +8155,72 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
              ***************************/
             Operator::I32Extend8S => {
                 let value = self.state.pop1()?.into_int_value();
-                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, ""));
+                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 =
-                    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, ""));
+                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 =
-                    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, ""));
+                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 =
-                    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, ""));
+                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 =
-                    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, ""));
+                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);
             }
 
@@ -8478,10 +8238,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let result =
-                    err!(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,
@@ -8500,10 +8261,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let result =
-                    err!(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,
@@ -8522,10 +8284,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let result =
-                    err!(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,
@@ -8544,10 +8307,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let result =
-                    err!(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,
@@ -8566,10 +8330,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     16,
                 )?;
-                let result =
-                    err!(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,
@@ -8590,10 +8355,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let element =
-                    err!(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,
@@ -8602,9 +8368,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 let res = err!(self.builder.build_insert_element(v, element, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load16Lane { ref memarg, lane } => {
@@ -8619,10 +8386,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let element =
-                    err!(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,
@@ -8631,9 +8399,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 let res = err!(self.builder.build_insert_element(v, element, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1_extra(res, i);
             }
             Operator::V128Load32Lane { ref memarg, lane } => {
@@ -8648,10 +8417,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let element =
-                    err!(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,
@@ -8660,9 +8430,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 let res = err!(self.builder.build_insert_element(v, element, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1_extra(res, i);
             }
             Operator::V128Load64Lane { ref memarg, lane } => {
@@ -8677,10 +8448,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let element =
-                    err!(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,
@@ -8689,9 +8461,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 let res = err!(self.builder.build_insert_element(v, element, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1_extra(res, i);
             }
 
@@ -8706,10 +8479,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8730,10 +8504,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8755,10 +8530,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8780,10 +8556,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8805,10 +8582,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     16,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8831,10 +8609,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8859,10 +8638,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8887,10 +8667,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8915,10 +8696,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let dead_load =
-                    err!(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,
@@ -8940,10 +8722,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -8967,10 +8750,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -8994,11 +8778,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9022,11 +8807,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9050,10 +8836,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9078,10 +8865,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9105,10 +8893,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9132,10 +8921,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9159,10 +8949,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9186,10 +8977,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let narrow_result =
-                    err!(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,
@@ -9215,20 +9007,22 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let dead_load =
-                    err!(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 =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                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)?;
             }
@@ -9243,20 +9037,22 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let dead_load =
-                    err!(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 =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                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)?;
             }
@@ -9271,20 +9067,22 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let dead_load =
-                    err!(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 =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                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)?;
             }
@@ -9292,36 +9090,40 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, i) = self.state.pop1_extra()?;
                 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                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 = 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Not => {
@@ -9340,9 +9142,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     v.get_type().const_zero(),
                     "",
                 ));
-                let res = err!(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_extra(
                     res,
                     (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
@@ -9377,9 +9180,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     lane_int_ty.const_int(u64::MAX, true),
                     "",
                 ));
-                let res = err!(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_extra(
                     res,
                     (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
@@ -9390,9 +9194,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i8x16(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(res, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I8x16ExtractLaneU { lane } => {
@@ -9400,9 +9205,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i8x16(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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, ""));
+                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 } => {
@@ -9410,9 +9216,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i16x8(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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, ""));
+                let res = err!(
+                    self.builder
+                        .build_int_s_extend(res, self.intrinsics.i32_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ExtractLaneU { lane } => {
@@ -9420,9 +9227,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let (v, _) = self.v128_into_i16x8(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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, ""));
+                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 } => {
@@ -9460,9 +9268,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self.builder.build_insert_element(v1, v2, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I16x8ReplaceLane { lane } => {
@@ -9472,9 +9281,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 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 = err!(self.builder.build_insert_element(v1, v2, idx, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::I32x4ReplaceLane { lane } => {
@@ -9485,9 +9295,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let i2 = i2.strip_pending();
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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 res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, ((i1 & i2)? & ExtraInfo::arithmetic_f32())?);
             }
@@ -9499,9 +9310,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let i2 = i2.strip_pending();
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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 res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state
                     .push1_extra(res, ((i1 & i2)? & ExtraInfo::arithmetic_f64())?);
             }
@@ -9522,9 +9334,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 };
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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 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 {
@@ -9549,9 +9362,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 };
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
                 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 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 {
@@ -9562,14 +9376,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::I8x16Swizzle => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let v1 = self.apply_pending_canonicalization(v1, i1)?;
-                let v1 = err!(self
-                    .builder
-                    .build_bit_cast(v1, self.intrinsics.i8x16_ty, ""))
+                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, ""))
+                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 =
@@ -9616,22 +9432,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                         "",
                     ));
                 }
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(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 = err!(self
-                    .builder
-                    .build_bit_cast(v1, self.intrinsics.i8x16_ty, ""))
+                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, ""))
+                let v2 = err!(
+                    self.builder
+                        .build_bit_cast(v2, self.intrinsics.i8x16_ty, "")
+                )
                 .into_vector_value();
                 let mask = VectorType::const_vector(
                     lanes
@@ -9641,9 +9460,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                         .as_slice(),
                 );
                 let res = err!(self.builder.build_shuffle_vector(v1, v2, mask, ""));
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load8x8S { ref memarg } => {
@@ -9656,20 +9476,24 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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), ""))
+                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, ""));
+                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 } => {
@@ -9682,20 +9506,24 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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), ""))
+                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, ""));
+                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 } => {
@@ -9708,21 +9536,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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, ""));
+                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 } => {
@@ -9735,21 +9567,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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, ""));
+                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 } => {
@@ -9762,21 +9598,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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, ""));
+                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 } => {
@@ -9789,21 +9629,25 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                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, ""));
+                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 } => {
@@ -9816,10 +9660,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let elem =
-                    err!(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,
@@ -9843,10 +9688,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let elem =
-                    err!(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,
@@ -9870,10 +9716,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     1,
                 )?;
-                let elem =
-                    err!(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,
@@ -9881,9 +9728,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     elem.as_instruction_value().unwrap(),
                 )?;
                 let res = self.splat_vector(elem, self.intrinsics.i8x16_ty)?;
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load16Splat { ref memarg } => {
@@ -9896,10 +9744,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     2,
                 )?;
-                let elem =
-                    err!(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,
@@ -9907,9 +9756,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     elem.as_instruction_value().unwrap(),
                 )?;
                 let res = self.splat_vector(elem, self.intrinsics.i16x8_ty)?;
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load32Splat { ref memarg } => {
@@ -9922,10 +9772,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     4,
                 )?;
-                let elem =
-                    err!(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,
@@ -9933,9 +9784,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     elem.as_instruction_value().unwrap(),
                 )?;
                 let res = self.splat_vector(elem, self.intrinsics.i32x4_ty)?;
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::V128Load64Splat { ref memarg } => {
@@ -9948,10 +9800,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     offset,
                     8,
                 )?;
-                let elem =
-                    err!(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,
@@ -9959,9 +9812,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     elem.as_instruction_value().unwrap(),
                 )?;
                 let res = self.splat_vector(elem, self.intrinsics.i64x2_ty)?;
-                let res = err!(self
-                    .builder
-                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
+                let res = err!(
+                    self.builder
+                        .build_bit_cast(res, self.intrinsics.i128_ty, "")
+                );
                 self.state.push1(res);
             }
             Operator::AtomicFence => {
@@ -10006,10 +9860,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     8,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 8)?;
-                let result =
-                    err!(self
-                        .builder
-                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                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)
@@ -10027,11 +9882,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 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 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)
@@ -10054,11 +9910,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 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 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)
@@ -10081,11 +9938,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 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 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)
@@ -10108,11 +9966,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 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 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)
@@ -10135,11 +9994,12 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 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 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)
@@ -10199,10 +10059,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                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
@@ -10222,10 +10083,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                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
@@ -10244,10 +10106,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                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
@@ -10266,10 +10129,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10285,9 +10149,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = err!(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 } => {
@@ -10302,10 +10167,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10321,9 +10187,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = err!(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 } => {
@@ -10367,10 +10234,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10386,9 +10254,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10403,10 +10272,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10422,9 +10292,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10439,10 +10310,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10458,9 +10330,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10504,10 +10377,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10523,9 +10397,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10540,10 +10415,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10559,9 +10435,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10605,10 +10482,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10624,9 +10502,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10641,10 +10520,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10660,9 +10540,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10677,10 +10558,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10696,9 +10578,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10742,10 +10625,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10761,9 +10645,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10778,10 +10663,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10797,9 +10683,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10843,10 +10730,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10862,9 +10750,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10879,10 +10768,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10898,9 +10788,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10915,10 +10806,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10934,9 +10826,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -10980,10 +10873,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10999,9 +10893,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11016,10 +10911,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11035,9 +10931,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11067,9 +10964,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11084,10 +10982,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11103,9 +11002,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11120,10 +11020,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11139,9 +11040,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11156,10 +11058,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11175,9 +11078,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11221,10 +11125,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11240,9 +11145,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11257,10 +11163,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11276,9 +11183,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11322,10 +11230,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11341,9 +11250,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11358,10 +11268,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11377,9 +11288,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11394,10 +11306,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11413,9 +11326,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11459,10 +11373,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11478,9 +11393,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11495,10 +11411,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11514,9 +11431,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11560,10 +11478,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 1)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i8_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11579,9 +11498,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11596,10 +11516,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 2)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i16_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11615,9 +11536,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11632,10 +11554,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let narrow_value =
-                    err!(self
-                        .builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let narrow_value = err!(self.builder.build_int_truncate(
+                    value,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -11651,9 +11574,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = err!(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 } => {
@@ -11700,14 +11624,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 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 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(
@@ -11729,9 +11655,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = err!(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 } => {
@@ -11749,14 +11676,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 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 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(
@@ -11778,9 +11707,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = err!(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 } => {
@@ -11832,14 +11762,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     1,
                 )?;
                 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 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(
@@ -11861,9 +11793,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = err!(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 } => {
@@ -11881,14 +11814,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     2,
                 )?;
                 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 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(
@@ -11910,9 +11845,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = err!(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 } => {
@@ -11930,14 +11866,16 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     4,
                 )?;
                 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 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(
@@ -11959,9 +11897,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = err!(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 } => {
@@ -12013,7 +11952,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     ],
                     "",
                 ));
-                self.state.push1(grow.try_as_basic_value().left().unwrap());
+                self.state.push1(grow.try_as_basic_value().unwrap_basic());
             }
             Operator::MemorySize { mem } => {
                 let memory_index = MemoryIndex::from_u32(mem);
@@ -12028,7 +11967,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ));
                 //size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
-                self.state.push1(size.try_as_basic_value().left().unwrap());
+                self.state.push1(size.try_as_basic_value().unwrap_basic());
             }
             Operator::MemoryInit { data_index, mem } => {
                 let (dest, src, len) = self.state.pop3()?;
@@ -12117,10 +12056,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::RefIsNull => {
                 let value = self.state.pop1()?.into_pointer_value();
                 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, ""));
+                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 } => {
@@ -12134,8 +12074,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1(value);
             }
             Operator::TableGet { table } => {
@@ -12156,28 +12095,30 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
-                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,
-                    )?,
-                    "",
-                ));
+                .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 = err!(self
-                    .builder
-                    .build_bit_cast(value, self.intrinsics.ptr_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))
@@ -12246,9 +12187,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             Operator::TableFill { table } => {
                 let table = self.intrinsics.i32_ty.const_int(table as u64, false);
                 let (start, elem, len) = self.state.pop3()?;
-                let elem = err!(self
-                    .builder
-                    .build_bit_cast(elem, self.intrinsics.ptr_ty, ""));
+                let elem = err!(
+                    self.builder
+                        .build_bit_cast(elem, self.intrinsics.ptr_ty, "")
+                );
                 err!(self.builder.build_call(
                     self.intrinsics.table_fill,
                     &[
@@ -12263,9 +12205,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
             }
             Operator::TableGrow { table } => {
                 let (elem, delta) = self.state.pop2()?;
-                let elem = err!(self
-                    .builder
-                    .build_bit_cast(elem, self.intrinsics.ptr_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))
@@ -12286,8 +12229,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .try_as_basic_value()
-                .left()
-                .unwrap();
+                .unwrap_basic();
                 self.state.push1(size);
             }
             Operator::TableSize { table } => {
@@ -12306,71 +12248,76 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     "",
                 ))
                 .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 = 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());
+                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().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 = 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());
+                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().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 = 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().left().unwrap());
+                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 } => {
@@ -12417,10 +12364,6 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
                 // Build the landing pad.
                 let null = self.intrinsics.ptr_ty.const_zero();
-                let exception_type = self.context.struct_type(
-                    &[self.intrinsics.ptr_ty.into(), self.intrinsics.i32_ty.into()],
-                    false,
-                );
 
                 let mut catch_tag_values = vec![];
                 let mut lpad_clauses: Vec<BasicValueEnum<'ctx>> = catches
@@ -12477,7 +12420,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.builder.position_at_end(lpad_block);
 
                     let res = err!(self.builder.build_landing_pad(
-                        exception_type,
+                        self.intrinsics.lpad_exception_ty,
                         self.intrinsics.personality,
                         &lpad_clauses,
                         false,
@@ -12508,15 +12451,9 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     err!(self.builder.build_unconditional_branch(catch_end_block));
 
                     self.builder.position_at_end(catch_specific_block);
-                    let vmctx_alloca = err!(self.build_or_get_vmctx_alloca());
-                    let vmctx_ptr = err!(self.builder.build_load(
-                        self.intrinsics.ptr_ty,
-                        vmctx_alloca,
-                        "vmctx"
-                    ));
                     let selector_value = err!(self.builder.build_call(
                         self.intrinsics.personality2,
-                        &[vmctx_ptr.into(), uw_exc.into()],
+                        &[self.ctx.basic().into(), uw_exc.into()],
                         "selector"
                     ));
                     err!(self.builder.build_unconditional_branch(catch_end_block));
@@ -12534,27 +12471,64 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                         (
                             &selector_value
                                 .try_as_basic_value()
-                                .left()
-                                .unwrap()
+                                .unwrap_basic()
                                 .into_int_value(),
                             catch_specific_block,
                         ),
                     ]);
 
-                    // The exception we get at this point is a wrapper around the [`WasmerException`]
-                    // type. This is needed because when we create the exception to pass it to
-                    // libunwind, the exception object needs to begin with a specific set of fields
-                    // (those in `__Unwind_Exception`). During unwinding, libunwind uses some of these
-                    // fields and we need to pass them back when rethrowing. This to say, we need to
-                    // keep the original exception passed to us by libunwind to be able to rethrow it.
+                    // 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 wasmer_exc = err!(self.builder.build_call(
-                        self.intrinsics.read_exception,
+                    let exnref = err!(self.builder.build_call(
+                        self.intrinsics.exception_into_exnref,
                         &[uw_exc.into()],
-                        "wasmer_exc_ptr"
+                        "exnref"
                     ));
 
-                    let wasmer_exc = wasmer_exc.as_any_value_enum().into_pointer_value();
+                    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() {
@@ -12569,65 +12543,52 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                                 err!(self.builder.build_unconditional_branch(*frame.br_dest()));
 
                                 self.builder.position_at_end(catch_end_block);
-                                catch_blocks.push((b, None, None));
+                                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, "catch_one_clause");
+                                let b = self.context.append_basic_block(
+                                    self.function,
+                                    format!("catch_one_clause_{tag}").as_str(),
+                                );
                                 self.builder.position_at_end(b);
 
-                                let wasmer_exc_phi = err!(self
-                                    .builder
-                                    .build_phi(self.intrinsics.ptr_ty, "wasmer_exc_phi"));
-                                wasmer_exc_phi.add_incoming(&[(&wasmer_exc, catch_end_block)]);
-
-                                // Get the type of the exception.
-                                let inner_exc_ty =
-                                    self.get_or_insert_exception_type(*tag, signature)?;
-
-                                // Cast the outer exception - a pointer - to a pointer to a struct of
-                                // type WasmerException.
-                                // let wasmer_exc_ptr = err!(self.builder.build_pointer_cast(
-                                //     exc,
-                                //     self.intrinsics.exc_ty,
-                                //     "wasmer_exc_ptr"
-                                // ));
-                                //
-                                // Not actually needed, since ptr is a single, unique type.
-
-                                // Points at the `data` field of the exception.
-                                let wasmer_exc_data_ptr_ptr = err!(self.builder.build_struct_gep(
-                                    self.intrinsics.exc_ty,
-                                    wasmer_exc_phi.as_basic_value().into_pointer_value(),
-                                    1,
-                                    "wasmer_exc_data_ptr_ptr"
-                                ));
+                                let exnref_phi = err!(
+                                    self.builder.build_phi(self.intrinsics.i32_ty, "exnref_phi")
+                                );
+                                exnref_phi.add_incoming(&[(&exnref, catch_end_block)]);
 
-                                let wasmer_exc_data_ptr = err!(self.builder.build_load(
-                                    self.intrinsics.ptr_ty,
-                                    wasmer_exc_data_ptr_ptr,
-                                    "wasmer_exc_data_ptr"
+                                // 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 wasmer_exc_data_ptr = wasmer_exc_data_ptr.into_pointer_value();
+                                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!(self.builder.build_struct_gep(
-                                            inner_exc_ty,
-                                            wasmer_exc_data_ptr,
-                                            i as u32,
-                                            &(name.clone() + "ptr")
-                                        ));
+                                        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,
@@ -12638,8 +12599,6 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
                                 let frame = self.state.frame_at_depth(*label)?;
 
-                                // todo: check that the types are compatible
-
                                 for (phi, value) in frame.phis().iter().zip(values.iter()) {
                                     phi.add_incoming(&[(value, b)])
                                 }
@@ -12647,70 +12606,52 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                                 err!(self.builder.build_unconditional_branch(*frame.br_dest()));
 
                                 self.builder.position_at_end(catch_end_block);
-                                catch_blocks.push((b, Some(wasmer_exc_phi), None));
+                                catch_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, "catch_one_ref_clause");
+                                let b = self.context.append_basic_block(
+                                    self.function,
+                                    format!("catch_one_ref_clause_{tag}").as_str(),
+                                );
                                 self.builder.position_at_end(b);
 
-                                let wasmer_exc_phi = err!(self
-                                    .builder
-                                    .build_phi(self.intrinsics.ptr_ty, "wasmer_exc_phi"));
-                                wasmer_exc_phi.add_incoming(&[(&wasmer_exc, catch_end_block)]);
-
-                                let uw_exc_ptr_phi = err!(self
-                                    .builder
-                                    .build_phi(self.intrinsics.ptr_ty, "uw_exc_ptr_phi"));
-                                uw_exc_ptr_phi.add_incoming(&[(&uw_exc, catch_end_block)]);
-
-                                // Get the type of the exception.
-                                let inner_exc_ty =
-                                    self.get_or_insert_exception_type(*tag, signature)?;
-
-                                // Cast the outer exception - a pointer - to a pointer to a struct of
-                                // type WasmerException.
-                                // let wasmer_exc_ptr = err!(self.builder.build_pointer_cast(
-                                //     exc,
-                                //     self.intrinsics.exc_ty,
-                                //     "wasmer_exc_ptr"
-                                // ));
-                                //
-                                // Not actually needed, since ptr is a single, unique type.
-
-                                // Points at the `data` field of the exception.
-                                let wasmer_exc_data_ptr_ptr = err!(self.builder.build_struct_gep(
-                                    self.intrinsics.exc_ty,
-                                    wasmer_exc_phi.as_basic_value().into_pointer_value(),
-                                    1,
-                                    "wasmer_exc_data_ptr"
-                                ));
+                                let exnref_phi = err!(
+                                    self.builder.build_phi(self.intrinsics.i32_ty, "exnref_phi")
+                                );
+                                exnref_phi.add_incoming(&[(&exnref, catch_end_block)]);
 
-                                let wasmer_exc_data_ptr = err!(self.builder.build_load(
-                                    self.intrinsics.ptr_ty,
-                                    wasmer_exc_data_ptr_ptr,
-                                    "wasmer_exc_data_ptr"
+                                // 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 wasmer_exc_data_ptr = wasmer_exc_data_ptr.into_pointer_value();
+                                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!(self.builder.build_struct_gep(
-                                            inner_exc_ty,
-                                            wasmer_exc_data_ptr,
-                                            i as u32,
-                                            &(name.clone() + "ptr")
-                                        ));
+                                        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,
@@ -12719,12 +12660,10 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                                     })
                                     .collect::<Result<Vec<_>, CompileError>>()?;
 
-                                values.push(uw_exc_ptr_phi.as_basic_value());
+                                values.push(exnref_phi.as_basic_value());
 
                                 let frame = self.state.frame_at_depth(*label)?;
 
-                                // todo: check that the types are compatible
-
                                 for (phi, value) in frame.phis().iter().zip(values.iter()) {
                                     phi.add_incoming(&[(value, b)])
                                 }
@@ -12732,7 +12671,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                                 err!(self.builder.build_unconditional_branch(*frame.br_dest()));
 
                                 self.builder.position_at_end(catch_end_block);
-                                catch_blocks.push((b, Some(wasmer_exc_phi), Some(uw_exc_ptr_phi)));
+                                catch_blocks.push((b, Some(exnref_phi)));
                             }
                             Catch::AllRef { label } => {
                                 let b = self
@@ -12740,60 +12679,53 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                                     .append_basic_block(self.function, "catch_all_ref_clause");
                                 self.builder.position_at_end(b);
 
-                                let uw_exc_ptr_phi = err!(self
-                                    .builder
-                                    .build_phi(self.intrinsics.ptr_ty, "uw_exc_ptr_phi"));
-                                uw_exc_ptr_phi.add_incoming(&[(&uw_exc, catch_end_block)]);
+                                let 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();
 
-                                // sanity check (todo): check that the phi has only one element
-
-                                for phi in phis.iter() {
-                                    phi.add_incoming(&[(&uw_exc_ptr_phi.as_basic_value(), b)])
-                                }
+                                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, None, Some(uw_exc_ptr_phi)));
+                                catch_blocks.push((b, Some(exnref_phi)));
                             }
                         }
                     }
 
                     for catch_info in &outer_catch_blocks {
-                        if let Some(phi) = catch_info.wasmer_exc_phi {
-                            phi.add_incoming(&[(
-                                &wasmer_exc.as_basic_value_enum(),
-                                catch_end_block,
-                            )]);
-                        }
-                        if let Some(phi) = catch_info.uw_exc_ptr_phi {
-                            phi.add_incoming(&[(&uw_exc.as_basic_value_enum(), catch_end_block)]);
+                        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()
-                    ));
+                    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
 
@@ -12801,8 +12733,8 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.builder.position_at_end(rethrow_block);
 
                     err!(self.builder.build_call(
-                        self.intrinsics.rethrow,
-                        &[uw_exc.into()],
+                        self.intrinsics.throw,
+                        &[self.ctx.basic().into(), exnref.into()],
                         "rethrow"
                     ));
                     // can't reach after an explicit throw!
@@ -12819,14 +12751,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 let catch_tags_and_blocks = catch_tag_values
                     .into_iter()
                     .zip(catch_blocks)
-                    .map(
-                        |(tag, (block, wasmer_exc_phi, uw_exc_ptr_phi))| TagCatchInfo {
-                            tag,
-                            catch_block: block,
-                            wasmer_exc_phi,
-                            uw_exc_ptr_phi,
-                        },
-                    )
+                    .map(|(tag, (block, exnref_phi))| TagCatchInfo {
+                        tag,
+                        catch_block: block,
+                        exnref_phi,
+                    })
                     .collect::<Vec<_>>();
                 self.state.push_landingpad(
                     maybe_lpad_block,
@@ -12845,17 +12774,11 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .get_insert_block()
                     .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
 
-                let tag = self.wasm_module.tags[TagIndex::from_u32(tag_index)];
-                let signature = &self.wasm_module.signatures[tag];
+                let 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())?;
 
-                let vmctx_alloca = err!(self.build_or_get_vmctx_alloca());
-                let vmctx_ptr =
-                    err!(self
-                        .builder
-                        .build_load(self.intrinsics.ptr_ty, vmctx_alloca, "vmctx"));
-
                 values.iter().enumerate().try_for_each(|(i, (v, _))| {
                     let t = type_to_llvm(self.intrinsics, params[i])?;
                     if t != v.get_type() {
@@ -12869,27 +12792,41 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     Ok(())
                 })?;
 
-                let exception_type: inkwell::types::StructType =
-                    self.get_or_insert_exception_type(tag_index, signature)?;
-
-                let size = exception_type.size_of().unwrap();
-
                 // Allocate the necessary bytes for the exception.
-                let exc = err!(self.builder.build_direct_call(
-                    self.intrinsics.alloc_exception,
-                    &[size.into()],
-                    "exception_ptr",
+                let 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",
+                    )
+                );
+                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 exc = exc.try_as_basic_value().left().unwrap();
-                let exc = exc.into_pointer_value();
+                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!(self.builder.build_struct_gep(
-                        exception_type,
-                        exc,
-                        i as u32,
-                        i.to_string().as_str(),
-                    ));
+                    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));
                 }
 
@@ -12900,15 +12837,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
 
                     err!(self.builder.build_invoke(
                         self.intrinsics.throw,
-                        &[
-                            self.intrinsics
-                                .i32_ty
-                                .const_int(tag_index as _, false)
-                                .into(),
-                            vmctx_ptr,
-                            exc.into(),
-                            size.into()
-                        ],
+                        &[self.ctx.basic(), exnref],
                         unreachable_block,
                         pad,
                         "throw",
@@ -12922,17 +12851,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                 } else {
                     err!(self.builder.build_call(
                         self.intrinsics.throw,
-                        &[
-                            // We pass in the module-local tag index, but it'll be translated
-                            // to a store-unique index in the `throw` intrinsic.
-                            self.intrinsics
-                                .i32_ty
-                                .const_int(tag_index as _, false)
-                                .into(),
-                            vmctx_ptr.into(),
-                            exc.into(),
-                            size.into()
-                        ],
+                        &[self.ctx.basic().into(), exnref.into()],
                         "throw"
                     ));
                     // can't reach after an explicit throw!
@@ -12947,7 +12866,7 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     .get_insert_block()
                     .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
 
-                let exc = self.state.pop1()?;
+                let exnref = self.state.pop1()?;
 
                 if let Some(pad) = self.state.get_innermost_landingpad() {
                     let unreachable_block = self
@@ -12955,8 +12874,8 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                         .append_basic_block(self.function, "_rethrow_unreachable");
 
                     err!(self.builder.build_invoke(
-                        self.intrinsics.rethrow,
-                        &[exc],
+                        self.intrinsics.throw,
+                        &[self.ctx.basic(), exnref],
                         unreachable_block,
                         pad,
                         "throw",
@@ -12969,9 +12888,9 @@ impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
                     self.builder.position_at_end(current_block);
                 } else {
                     err!(self.builder.build_call(
-                        self.intrinsics.rethrow,
-                        &[exc.into(),],
-                        "rethrow"
+                        self.intrinsics.throw,
+                        &[self.ctx.basic().into(), exnref.into()],
+                        "throw"
                     ));
                     // can't reach after an explicit throw!
                     err!(self.builder.build_unreachable());
diff --git a/lib/compiler-llvm/src/translator/intrinsics.rs b/lib/compiler-llvm/src/translator/intrinsics.rs
index 661fe5b7c5..1aa8905c1a 100644
--- a/lib/compiler-llvm/src/translator/intrinsics.rs
+++ b/lib/compiler-llvm/src/translator/intrinsics.rs
@@ -4,11 +4,12 @@
 //!
 //! [llvm-intrinsics]: https://llvm.org/docs/LangRef.html#intrinsic-functions
 
+use crate::LLVM;
 use crate::abi::Abi;
 use crate::error::err;
-use crate::LLVM;
 use inkwell::values::BasicMetadataValueEnum;
 use inkwell::{
+    AddressSpace,
     attributes::{Attribute, AttributeLoc},
     builder::Builder,
     context::Context,
@@ -22,9 +23,8 @@ 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 wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType as FuncType, GlobalIndex, LocalFunctionIndex,
@@ -50,9 +50,8 @@ 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 | Type::ExceptionRef | Type::ExternRef => {
-            Ok(intrinsics.ptr_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()),
     }
 }
 
@@ -105,6 +104,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>,
@@ -158,6 +167,8 @@ pub struct Intrinsics<'ctx> {
     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>,
@@ -184,7 +195,6 @@ pub struct Intrinsics<'ctx> {
     pub ptr_ty: PointerType<'ctx>,
 
     pub anyfunc_ty: StructType<'ctx>,
-    pub exc_ty: StructType<'ctx>,
 
     pub i1_zero: IntValue<'ctx>,
     pub i8_zero: IntValue<'ctx>,
@@ -246,10 +256,10 @@ pub struct Intrinsics<'ctx> {
 
     // EH
     pub throw: FunctionValue<'ctx>,
-    pub rethrow: FunctionValue<'ctx>,
     pub alloc_exception: FunctionValue<'ctx>,
-    pub delete_exception: FunctionValue<'ctx>,
-    pub read_exception: FunctionValue<'ctx>,
+    pub read_exnref: FunctionValue<'ctx>,
+    pub exception_into_exnref: FunctionValue<'ctx>,
+    pub lpad_exception_ty: StructType<'ctx>,
 
     // Debug
     pub debug_ptr: FunctionValue<'ctx>,
@@ -626,6 +636,32 @@ impl<'ctx> Intrinsics<'ctx> {
                 None,
             ),
 
+            minimum_f32: module.add_function("llvm.minimum.f32", ret_f32_take_f32_f32, None),
+            minimum_f64: module.add_function("llvm.minimum.f64", ret_f64_take_f64_f64, None),
+            minimum_f32x4: module.add_function(
+                "llvm.minimum.v4f32",
+                ret_f32x4_take_f32x4_f32x4,
+                None,
+            ),
+            minimum_f64x2: module.add_function(
+                "llvm.minimum.v2f64",
+                ret_f64x2_take_f64x2_f64x2,
+                None,
+            ),
+
+            maximum_f32: module.add_function("llvm.maximum.f32", ret_f32_take_f32_f32, None),
+            maximum_f64: module.add_function("llvm.maximum.f64", ret_f64_take_f64_f64, None),
+            maximum_f32x4: module.add_function(
+                "llvm.maximum.v4f32",
+                ret_f32x4_take_f32x4_f32x4,
+                None,
+            ),
+            maximum_f64x2: module.add_function(
+                "llvm.maximum.v2f64",
+                ret_f64x2_take_f64x2_f64x2,
+                None,
+            ),
+
             fpext_f32: module.add_function(
                 "llvm.experimental.constrained.fpext.f64.f32",
                 ret_f64_take_f32_md,
@@ -730,6 +766,7 @@ impl<'ctx> Intrinsics<'ctx> {
             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: module.add_function("__chkstk", void_ty.fn_type(&[], false), None),
             void_ty,
             i1_ty,
             i2_ty,
@@ -753,7 +790,6 @@ impl<'ctx> Intrinsics<'ctx> {
             i32x8_ty,
 
             anyfunc_ty,
-            exc_ty: context.struct_type(&[i32_ty.into(), ptr_ty.into(), i64_ty.into()], false),
             i1_zero,
             i8_zero,
             i32_zero,
@@ -1028,32 +1064,25 @@ impl<'ctx> Intrinsics<'ctx> {
 
             throw: module.add_function(
                 "wasmer_vm_throw",
-                void_ty.fn_type(
-                    &[i32_ty.into(), ptr_ty.into(), ptr_ty.into(), i64_ty.into()],
-                    false,
-                ),
-                None,
-            ),
-            rethrow: module.add_function(
-                "wasmer_vm_rethrow",
-                void_ty.fn_type(&[ptr_ty.into()], false),
+                void_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
                 None,
             ),
             alloc_exception: module.add_function(
                 "wasmer_vm_alloc_exception",
-                ptr_ty.fn_type(&[i64_ty.into()], false),
+                i32_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
                 None,
             ),
-            delete_exception: module.add_function(
-                "wasmer_vm_delete_exception",
-                void_ty.fn_type(&[ptr_ty.into()], false),
+            read_exnref: module.add_function(
+                "wasmer_vm_read_exnref",
+                ptr_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
                 None,
             ),
-            read_exception: module.add_function(
-                "wasmer_vm_read_exception",
-                ptr_ty.fn_type(&[ptr_ty.into()], false),
+            exception_into_exnref: module.add_function(
+                "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: module.add_function(
                 "wasmer_vm_dbg_usize",
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 be9188fc54..345009f8c9 100644
--- a/lib/compiler-llvm/src/translator/state.rs
+++ b/lib/compiler-llvm/src/translator/state.rs
@@ -50,38 +50,35 @@ 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::Landingpad { 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, .. }
-            | ControlFrame::Landingpad { 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, .. }
-            | ControlFrame::Landingpad { ref next_phis, .. } => next_phis.as_slice(),
         }
     }
 
     /// PHI nodes for stack values in the loop body.
     pub fn loop_body_phis(&self) -> &[PhiValue<'ctx>] {
         match self {
-            ControlFrame::Loop {
-                ref loop_body_phis, ..
-            } => loop_body_phis.as_slice(),
+            ControlFrame::Loop { loop_body_phis, .. } => loop_body_phis.as_slice(),
             _ => &[],
         }
     }
@@ -223,11 +220,9 @@ pub struct TagCatchInfo<'ctx> {
     pub tag: u32,
     // The catch block
     pub catch_block: BasicBlock<'ctx>,
-    // The PHI node to receive the exception object
-    pub wasmer_exc_phi: Option<PhiValue<'ctx>>,
-    // The PHI node to receive the libunwind exception pointer,
-    // which stands in as the exnref for now
-    pub uw_exc_ptr_phi: Option<PhiValue<'ctx>>,
+    // 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)]
diff --git a/lib/compiler-singlepass/Cargo.toml b/lib/compiler-singlepass/Cargo.toml
index a0d961288b..87569cae6e 100644
--- a/lib/compiler-singlepass/Cargo.toml
+++ b/lib/compiler-singlepass/Cargo.toml
@@ -14,28 +14,31 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = ["translator", "compiler"], default-features = false }
-wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = ["std"] }
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = ["translator", "compiler"] }
+wasmer-types = { path = "../types", version = "=6.1.0", features = ["std"], default-features = false }
 hashbrown = { workspace = true, optional = true }
 gimli = { workspace = true, optional = true }
 enumset.workspace = true
 more-asserts.workspace = true
-dynasm = "4.0.0"
-dynasmrt = "4.0.0"
+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 = { workspace = true, optional = true }
 
 [dev-dependencies]
-target-lexicon = { workspace = true, default-features = false }
+target-lexicon = { workspace = true }
 
 [badges]
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ["std", "rayon", "unwind", "avx"]
+default = ["std", "rayon", "unwind", "avx", "riscv"]
 wasm = ["std", "unwind", "avx"]
 std = ["wasmer-compiler/std", "wasmer-types/std"]
 core = ["hashbrown", "wasmer-types/core"]
@@ -43,6 +46,7 @@ unwind = ["gimli"]
 sse = []
 avx = []
 enable-serde = []
+riscv = []
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/compiler-singlepass/LICENSE b/lib/compiler-singlepass/LICENSE
index aa292ec0ad..498ee6ea6a 100644
--- a/lib/compiler-singlepass/LICENSE
+++ b/lib/compiler-singlepass/LICENSE
@@ -4,7 +4,7 @@ License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
 Parameters
 
 Licensor:             Wasmer, Inc.
-Licensed Work:        Wasmer Singlepass Version 6.0.0 or later.  The Licensed Work is
+Licensed Work:        Wasmer Singlepass Version 6.1.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
@@ -34,6 +34,12 @@ Additional Use Grant: You may make production use of the Licensed Work provided
                       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.
+
+                      For purposes of this License, any code, binaries, or other output
+                      generated by the Licensed Work ("Generated Code") shall be deemed part
+                      of the Licensed Work and subject to the same terms, conditions, and
+                      restrictions as the Licensed Work itself, including the limitations on
+                      production use and the Change Date.
 Change Date:          Four years from the date the Licensed Work is published
 Change License:       MPL 2.0
 
diff --git a/lib/compiler-singlepass/README.md b/lib/compiler-singlepass/README.md
index 48a0d6dde0..955f7c68dc 100644
--- a/lib/compiler-singlepass/README.md
+++ b/lib/compiler-singlepass/README.md
@@ -2,7 +2,10 @@
 [![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
diff --git a/lib/compiler-singlepass/src/address_map.rs b/lib/compiler-singlepass/src/address_map.rs
index 666000f07b..7e5505841c 100644
--- a/lib/compiler-singlepass/src/address_map.rs
+++ b/lib/compiler-singlepass/src/address_map.rs
@@ -1,5 +1,5 @@
-use wasmer_compiler::types::address_map::{FunctionAddressMap, InstructionAddressMap};
 use wasmer_compiler::FunctionBodyData;
+use wasmer_compiler::types::address_map::{FunctionAddressMap, InstructionAddressMap};
 use wasmer_types::SourceLoc;
 
 pub fn get_function_address_map(
diff --git a/lib/compiler-singlepass/src/arm64_decl.rs b/lib/compiler-singlepass/src/arm64_decl.rs
index e3deca42b1..993baf630c 100644
--- a/lib/compiler-singlepass/src/arm64_decl.rs
+++ b/lib/compiler-singlepass/src/arm64_decl.rs
@@ -1,14 +1,52 @@
 //! ARM64 structures.
 
-use crate::{
-    common_decl::{MachineState, MachineValue, RegisterIndex},
-    location::{CombinedRegister, Reg as AbstractReg},
-};
-use std::collections::BTreeMap;
+use crate::location::{CombinedRegister, Reg as AbstractReg};
 use std::slice::Iter;
 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)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -101,12 +139,6 @@ impl From<NEON> for u8 {
 }
 
 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)
-    }
     fn into_index(self) -> usize {
         self as usize
     }
@@ -153,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
     }
@@ -211,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,
+        }
     }
 }
 
@@ -227,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())
@@ -242,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.
@@ -311,28 +393,17 @@ impl ArgumentRegisterAllocator {
                     _ => {
                         return Err(CompileError::Codegen(format!(
                             "No register available for {calling_convention:?} and type {ty}"
-                        )))
+                        )));
                     }
                 }
             }
             _ => {
                 return Err(CompileError::Codegen(format!(
                     "No register available for {calling_convention:?} and type {ty}"
-                )))
+                )));
             }
         };
 
         Ok(ret)
     }
 }
-
-/// 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: usize::MAX,
-    }
-}
diff --git a/lib/compiler-singlepass/src/codegen.rs b/lib/compiler-singlepass/src/codegen.rs
index 795d9665d3..0e333afdcb 100644
--- a/lib/compiler-singlepass/src/codegen.rs
+++ b/lib/compiler-singlepass/src/codegen.rs
@@ -7,15 +7,21 @@ use crate::{
     common_decl::*,
     config::Singlepass,
     location::{Location, Reg},
-    machine::{Label, Machine, MachineStackOffset, NATIVE_PAGE_SIZE},
+    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, iter};
+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},
@@ -25,7 +31,6 @@ use wasmer_compiler::{
         BlockType as WpTypeOrFuncType, HeapType as WpHeapType, Operator, RefType as WpRefType,
         ValType as WpType,
     },
-    FunctionBodyData,
 };
 
 #[cfg(feature = "unwind")]
@@ -33,11 +38,15 @@ use wasmer_compiler::types::unwind::CompiledFunctionUnwindInfo;
 
 use wasmer_types::target::CallingConvention;
 use wasmer_types::{
-    entity::{EntityRef, PrimaryMap},
     CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex,
     MemoryIndex, MemoryStyle, ModuleInfo, SignatureIndex, TableIndex, TableStyle, TrapCode, Type,
     VMBuiltinFunctionIndex, VMOffsets,
+    entity::{EntityRef, PrimaryMap},
 };
+
+#[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> {
     // Immutable properties assigned at creation time.
@@ -66,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,
@@ -88,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>,
@@ -99,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 {
@@ -111,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),
+        }
     }
 }
 
@@ -223,26 +165,51 @@ 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,
@@ -263,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 let Location::GPR(x) = loc {
+            self.machine.reserve_gpr(x);
+        } else if let Location::SIMD(x) = loc {
+            self.machine.reserve_simd(x);
         }
-        if zeroed {
-            for i in 0..tys.len() {
-                self.machine.zero_location(Size::S64, ret[i])?;
-            }
-        }
-        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(())
     }
 
@@ -530,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))
@@ -579,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,
@@ -638,6 +519,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 _ => codegen_error!("singlepass init_local unimplemented"),
             };
             let loc = self.machine.get_call_param_location(
+                sig.results().len(),
                 i + 1,
                 sz,
                 &mut stack_offset,
@@ -650,8 +532,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()),
         )?;
 
@@ -676,7 +560,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)
     }
@@ -687,7 +571,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() {
@@ -714,121 +598,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;
 
@@ -838,13 +701,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,
             ));
@@ -852,64 +727,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(),
-                    ))
+                    ));
                 }
             }
         }
@@ -925,107 +765,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(())
     }
 
@@ -1058,21 +857,8 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         )
     }
 
-    pub fn get_state_diff(&mut self) -> usize {
-        if !self.track_state {
-            return 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.
@@ -1082,32 +868,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
@@ -1115,12 +901,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 != usize::MAX {
-            return Err(CompileError::Codegen(
-                "emit_head: wasm_inst_offset not usize::MAX".to_owned(),
-            ));
-        }
         Ok(())
     }
 
@@ -1140,11 +922,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;
@@ -1157,15 +935,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,
@@ -1177,18 +951,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)
@@ -1198,12 +971,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 {
@@ -1218,12 +1066,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;
                     }
                 }
                 _ => {}
@@ -1239,15 +1088,9 @@ 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();
 
@@ -1303,23 +1146,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)?;
                     }
@@ -1330,34 +1160,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],
                         )
@@ -1372,20 +1189,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],
                         )
@@ -1399,351 +1210,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.
@@ -1757,255 +1575,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
@@ -2017,12 +1758,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)?;
             }
@@ -2030,191 +1768,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
@@ -2225,66 +1904,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)?;
@@ -2294,14 +1948,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)?;
@@ -2309,17 +1958,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)?;
@@ -2329,14 +1973,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)?;
@@ -2344,289 +1983,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)?;
             }
@@ -2641,36 +2176,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;
                     }
                 }
 
@@ -2698,35 +2221,9 @@ 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,
@@ -2738,36 +2235,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;
                     }
                 }
 
@@ -2818,10 +2305,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(
@@ -2843,13 +2333,13 @@ 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,
                     Location::Memory(
@@ -2860,22 +2350,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,
@@ -2884,8 +2373,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 =
@@ -2894,243 +2381,232 @@ 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 => {}
@@ -3148,33 +2624,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,
@@ -3184,21 +2654,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,
@@ -3214,8 +2681,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(
@@ -3226,26 +2694,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) =
@@ -3267,20 +2735,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,
@@ -3290,14 +2758,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) =
@@ -3319,33 +2787,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 } => {
                 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(
@@ -3358,42 +2830,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,
@@ -3415,14 +2878,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,
@@ -3444,12 +2902,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,
@@ -3471,12 +2926,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,
@@ -3498,12 +2950,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,
@@ -3525,12 +2974,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,
@@ -3552,8 +2998,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,
@@ -3575,10 +3021,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,
@@ -3590,7 +3034,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,
@@ -3601,8 +3046,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,
@@ -3624,8 +3069,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,
@@ -3647,12 +3092,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,
@@ -3674,14 +3116,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,
@@ -3703,12 +3140,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,
@@ -3730,12 +3164,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,
@@ -3757,12 +3188,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,
@@ -3784,12 +3212,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,
@@ -3811,12 +3236,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,
@@ -3838,12 +3260,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,
@@ -3865,8 +3284,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,
@@ -3889,10 +3308,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,
@@ -3904,7 +3321,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,
@@ -3915,8 +3333,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,
@@ -3938,8 +3356,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,
@@ -3961,8 +3379,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,
@@ -3984,105 +3402,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)?;
             }
@@ -4092,16 +3514,17 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     .targets()
                     .collect::<Result<Vec<_>, _>>()
                     .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {e:?}")))?;
-                let cond = self.pop_value_released()?;
+                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)?;
 
@@ -4111,95 +3534,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() {
@@ -4208,52 +3607,26 @@ 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()?;
-                        }
-                        _ => {}
+                    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 => {
@@ -4267,12 +3640,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,
@@ -4294,12 +3664,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,
@@ -4321,12 +3688,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,
@@ -4348,8 +3712,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,
@@ -4371,8 +3735,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,
@@ -4394,8 +3758,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,
@@ -4417,12 +3781,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,
@@ -4444,12 +3805,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,
@@ -4471,12 +3829,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,
@@ -4498,12 +3853,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,
@@ -4525,8 +3877,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,
@@ -4548,8 +3900,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,
@@ -4571,8 +3923,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,
@@ -4594,8 +3946,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,
@@ -4617,13 +3969,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,
@@ -4646,13 +3995,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,
@@ -4675,13 +4021,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,
@@ -4704,13 +4047,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,
@@ -4733,13 +4073,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,
@@ -4762,13 +4099,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,
@@ -4791,13 +4125,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,
@@ -4820,13 +4151,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,
@@ -4849,13 +4177,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,
@@ -4878,13 +4203,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,
@@ -4907,13 +4229,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,
@@ -4936,13 +4255,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,
@@ -4965,13 +4281,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,
@@ -4994,13 +4307,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,
@@ -5023,13 +4333,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,
@@ -5052,13 +4359,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,
@@ -5081,13 +4385,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,
@@ -5110,13 +4411,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,
@@ -5139,13 +4437,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,
@@ -5168,13 +4463,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,
@@ -5197,13 +4489,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,
@@ -5226,13 +4515,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,
@@ -5255,13 +4541,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,
@@ -5284,13 +4567,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,
@@ -5313,13 +4593,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,
@@ -5342,13 +4619,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,
@@ -5371,13 +4645,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,
@@ -5400,13 +4671,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,
@@ -5429,13 +4697,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,
@@ -5458,13 +4723,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,
@@ -5487,13 +4749,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,
@@ -5516,13 +4775,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,
@@ -5545,13 +4801,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,
@@ -5574,13 +4827,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,
@@ -5603,13 +4853,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,
@@ -5632,13 +4879,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,
@@ -5661,13 +4905,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,
@@ -5690,13 +4931,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,
@@ -5719,13 +4957,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,
@@ -5748,13 +4983,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,
@@ -5777,13 +5009,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,
@@ -5806,13 +5035,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,
@@ -5835,14 +5061,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,
@@ -5866,14 +5089,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,
@@ -5897,14 +5117,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,
@@ -5928,14 +5145,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,
@@ -5959,14 +5173,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,
@@ -5990,14 +5201,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,
@@ -6021,14 +5229,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,
@@ -6053,8 +5258,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(
@@ -6065,52 +5270,35 @@ 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,
                     Location::Memory(
@@ -6123,31 +5311,34 @@ 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,
                     Location::Memory(
@@ -6160,36 +5351,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 } => {
@@ -6207,35 +5389,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,
@@ -6249,38 +5424,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()),
                 )?;
 
-                // 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 {
@@ -6290,7 +5455,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,
@@ -6300,20 +5464,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,
@@ -6329,16 +5491,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,
@@ -6348,30 +5509,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,
@@ -6381,20 +5546,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,
@@ -6410,9 +5573,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(
@@ -6423,26 +5586,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) =
@@ -6464,20 +5626,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,
@@ -6487,24 +5649,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) =
@@ -6526,20 +5678,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,
@@ -6549,23 +5701,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) =
@@ -6587,33 +5729,27 @@ 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,
                 )?;
             }
             _ => {
@@ -6626,10 +5762,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)?;
@@ -6666,7 +5812,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 {
@@ -6675,7 +5823,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);
                 }
@@ -6692,9 +5840,25 @@ 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()),
+                &body,
+            );
+            callbacks.asm_memory_buffer(
+                &CompiledKind::Local(self.local_func_index, self.function_name.clone()),
+                arch,
+                &body,
+                assembly_comments,
+            )?;
+        }
+
         Ok((
             CompiledFunction {
                 body: FunctionBody { body, unwind_info },
@@ -6710,10 +5874,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 00090c344a..6555d1fdaa 100644
--- a/lib/compiler-singlepass/src/common_decl.rs
+++ b/lib/compiler-singlepass/src/common_decl.rs
@@ -1,113 +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)]
-#[allow(dead_code)]
-pub struct MachineStateDiff {
-    /// Link to the previous diff this diff is based on, or `None` if this is the first diff.
-    pub last: Option<usize>,
-
-    /// 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)]
-#[allow(dead_code)]
-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,
@@ -116,152 +6,17 @@ pub enum Size {
     S64,
 }
 
-/// A kind of suspend offset.
-#[allow(dead_code)]
-#[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.
-#[allow(dead_code)]
-#[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.contains_key(k))
-                    .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 0b2d1b4272..bbd77902ac 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,33 @@ use crate::machine::{
     gen_import_call_trampoline, gen_std_dynamic_import_trampoline, gen_std_trampoline,
 };
 use crate::machine_arm64::MachineARM64;
+#[cfg(feature = "riscv")]
+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, 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::{
+    Compiler, CompilerConfig, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader,
+    ModuleMiddleware, ModuleMiddlewareChain, ModuleTranslationState,
     types::{
         function::{Compilation, CompiledFunction, FunctionBody, UnwindInfo},
         module::CompileModuleInfo,
         section::SectionIndex,
     },
-    Compiler, CompilerConfig, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader,
-    ModuleMiddleware, ModuleMiddlewareChain, ModuleTranslationState,
 };
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::target::{Architecture, CallingConvention, CpuFeature, Target};
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType, LocalFunctionIndex, MemoryIndex, ModuleInfo,
-    TableIndex, TrapCode, TrapInformation, VMOffsets,
+    TableIndex, TrapCode, TrapInformation, Type, VMOffsets,
 };
 
 /// A compiler that compiles a WebAssembly module with Singlepass.
@@ -78,25 +82,31 @@ impl Compiler for SinglepassCompiler {
         _module_translation: &ModuleTranslationState,
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
     ) -> Result<Compilation, CompileError> {
-        match target.triple().architecture {
+        let arch = target.triple().architecture;
+        match arch {
             Architecture::X86_64 => {}
             Architecture::Aarch64(_) => {}
+            #[cfg(feature = "riscv")]
+            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(),
+                    ));
+                }
+            },
         };
 
         // Generate the frametable
@@ -126,6 +136,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<_>>()
@@ -142,6 +153,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<'_>)>>()
@@ -165,7 +177,7 @@ impl Compiler for SinglepassCompiler {
                     }
                 }
 
-                match target.triple().architecture {
+                match arch {
                     Architecture::X86_64 => {
                         let machine = MachineX86_64::new(Some(target.clone()))?;
                         let mut generator = FuncGen::new(
@@ -185,7 +197,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()));
@@ -206,7 +218,29 @@ impl Compiler for SinglepassCompiler {
                             generator.feed_operator(op)?;
                         }
 
-                        generator.finalize(input)
+                        generator.finalize(input, arch)
+                    }
+                    #[cfg(feature = "riscv")]
+                    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!(),
                 }
@@ -220,7 +254,23 @@ impl Compiler for SinglepassCompiler {
             .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()),
+                        &body.body,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::FunctionCallTrampoline(func_type.clone()),
+                        arch,
+                        &body.body,
+                        HashMap::new(),
+                    )?;
+                }
+
+                Ok(body)
+            })
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
             .collect::<PrimaryMap<_, _>>();
@@ -229,13 +279,26 @@ 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()),
+                        &body.body,
+                    );
+                    callbacks.asm_memory_buffer(
+                        &CompiledKind::DynamicFunctionTrampoline(func_type.clone()),
+                        arch,
+                        &body.body,
+                        HashMap::new(),
+                    )?;
+                }
+                Ok(body)
             })
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
@@ -304,8 +367,8 @@ mod tests {
     use target_lexicon::triple;
     use wasmer_compiler::Features;
     use wasmer_types::{
-        target::{CpuFeature, Triple},
         MemoryStyle, TableStyle,
+        target::{CpuFeature, Triple},
     };
 
     fn dummy_compilation_ingredients<'a>() -> (
@@ -353,17 +416,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 71cd41d614..65b244ab8a 100644
--- a/lib/compiler-singlepass/src/config.rs
+++ b/lib/compiler-singlepass/src/config.rs
@@ -1,19 +1,69 @@
 // 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 crate::{compiler::SinglepassCompiler, machine::AssemblyComment};
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{self, Write},
+    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::{
-    target::{CpuFeature, Target},
     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 })
+    }
+
+    /// Writes the object file memory buffer to a debug file.
+    pub fn obj_memory_buffer(&self, kind: &CompiledKind, mem_buffer: &[u8]) {
+        let mut path = self.debug_dir.clone();
+        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,
+        arch: Architecture,
+        mem_buffer: &[u8],
+        assembly_comments: HashMap<usize, AssemblyComment>,
+    ) -> Result<(), wasmer_types::CompileError> {
+        let mut path = self.debug_dir.clone();
+        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>,
 }
 
 impl Singlepass {
@@ -23,6 +73,7 @@ impl Singlepass {
         Self {
             enable_nan_canonicalization: true,
             middlewares: vec![],
+            callbacks: None,
         }
     }
 
@@ -30,6 +81,13 @@ 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
+    }
 }
 
 impl CompilerConfig for Singlepass {
@@ -45,9 +103,7 @@ impl CompilerConfig for Singlepass {
 
     /// Gets the supported features for this compiler in the given target
     fn supported_features_for_target(&self, _target: &Target) -> Features {
-        let mut features = Features::default();
-        features.multi_value(false);
-        features
+        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 98e954da53..30e8af7689 100644
--- a/lib/compiler-singlepass/src/dwarf.rs
+++ b/lib/compiler-singlepass/src/dwarf.rs
@@ -1,12 +1,12 @@
 use gimli::{
-    write::{Address, EndianVec, Result, Writer},
     RunTimeEndian, SectionId,
+    write::{Address, EndianVec, Result, Writer},
 };
 use wasmer_compiler::types::{
     relocation::{Relocation, RelocationKind, RelocationTarget},
     section::{CustomSection, CustomSectionProtection, SectionBody},
 };
-use wasmer_types::{entity::EntityRef, target::Endianness, LocalFunctionIndex};
+use wasmer_types::{LocalFunctionIndex, entity::EntityRef, target::Endianness};
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {
diff --git a/lib/compiler-singlepass/src/emitter_arm64.rs b/lib/compiler-singlepass/src/emitter_arm64.rs
index 1799f5c7aa..90471125c8 100644
--- a/lib/compiler-singlepass/src/emitter_arm64.rs
+++ b/lib/compiler-singlepass/src/emitter_arm64.rs
@@ -3,19 +3,21 @@ pub use crate::{
     location::{Multiplier, Reg},
     machine::{Label, Offset},
 };
-use crate::{codegen_error, common_decl::Size, location::Location as AbstractLocation};
-use dynasm::dynasm;
+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::{
-    target::CallingConvention, CompileError, FunctionIndex, FunctionType, Type, VMOffsets,
+    CompileError, FunctionIndex, FunctionType, Type, VMOffsets, target::CallingConvention,
 };
 
 type Assembler = VecAssembler<Aarch64Relocation>;
@@ -25,7 +27,7 @@ type Assembler = VecAssembler<Aarch64Relocation>;
 /// `target_arch`, but it sees the `target_arch` of the proc-macro itself, which
 /// is always equal to host, even when cross-compiling.
 macro_rules! dynasm {
-    ($a:expr ; $($tt:tt)*) => {
+    ($a:expr_2021 ; $($tt:tt)*) => {
         dynasm::dynasm!(
             $a
             ; .arch aarch64
@@ -235,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(
@@ -351,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,
@@ -490,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,
@@ -535,17 +529,17 @@ impl EmitterARM64 for Assembler {
         match (sz, reg, addr) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, disp)) => {
                 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 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 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)) => {
@@ -555,12 +549,12 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S64, Location::SIMD(reg), Location::Memory(addr, disp)) => {
                 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 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)) => {
@@ -1414,8 +1408,13 @@ 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)) => {
                 dynasm!(self ; cmp X(dst), X(src));
             }
@@ -1446,7 +1445,7 @@ impl EmitterARM64 for Assembler {
                 }
                 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(())
     }
@@ -1504,29 +1503,25 @@ impl EmitterARM64 for Assembler {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
                 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)) => {
+            (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)) => {
+            (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)) => {
+            (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)) => {
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm > 31 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1564,29 +1559,25 @@ impl EmitterARM64 for Assembler {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
                 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)) => {
+            (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)) => {
+            (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)) => {
+            (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)) => {
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1624,29 +1615,25 @@ impl EmitterARM64 for Assembler {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
                 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)) => {
+            (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)) => {
+            (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)) => {
+            (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)) => {
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1673,8 +1660,7 @@ impl EmitterARM64 for Assembler {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
                 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)) => {
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 let imm = imm as u32;
 
                 if imm == 0 || imm > 63 {
@@ -1682,8 +1668,7 @@ impl EmitterARM64 for Assembler {
                 }
                 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)) => {
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
                 let imm = imm as u32;
 
                 if imm == 0 || imm > 63 {
@@ -1691,8 +1676,7 @@ impl EmitterARM64 for Assembler {
                 }
                 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)) => {
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -1701,15 +1685,13 @@ impl EmitterARM64 for Assembler {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
                 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)) => {
+            (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)) => {
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -1924,7 +1906,7 @@ impl EmitterARM64 for Assembler {
                 dynasm!(self ; sdiv X(dst), X(src1), X(src2));
             }
             _ => codegen_error!(
-                "singlepass can't emit UDIV {:?} {:?} {:?} {:?}",
+                "singlepass can't emit SDIV {:?} {:?} {:?} {:?}",
                 sz,
                 src1,
                 src2,
@@ -2850,18 +2832,27 @@ pub fn gen_std_trampoline_arm64(
     );
 
     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,
@@ -2885,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());
                     }
                     _ => (),
                 };
@@ -2908,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;
@@ -2930,18 +2906,41 @@ pub fn gen_std_trampoline_arm64(
 
     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), 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();
@@ -3003,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
                             }
                         },
@@ -3129,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
-                };
-                let stack_offset = if stack_offset & 15 != 0 {
-                    stack_offset + 8
-                } else {
-                    stack_offset
+                    (sig.params().len() as u32) * 8
                 };
-                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,
@@ -3169,22 +3162,22 @@ 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() {
@@ -3198,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;
@@ -3237,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)?;
@@ -3252,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),
diff --git a/lib/compiler-singlepass/src/emitter_riscv.rs b/lib/compiler-singlepass/src/emitter_riscv.rs
new file mode 100644
index 0000000000..b68f877d17
--- /dev/null
+++ b/lib/compiler-singlepass/src/emitter_riscv.rs
@@ -0,0 +1,2126 @@
+//! 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 dynasm::dynasm;
+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,
+    ) -> 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) -> Result<(), CompileError>;
+    fn emit_on_false_label_far(&mut self, cond: Location, label: Label)
+    -> Result<(), CompileError>;
+    fn emit_on_true_label_far(&mut self, cond: Location, label: Label) -> Result<(), CompileError>;
+    fn emit_on_true_label(&mut self, cond: Location, label: Label) -> Result<(), CompileError>;
+
+    fn emit_j_label(&mut self, label: Label) -> 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,
+    ) -> 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)?;
+        self.emit_label(jump)?;
+        self.emit_j_label(label)?;
+
+        self.emit_label(cont)?;
+
+        Ok(())
+    }
+
+    fn emit_on_false_label(&mut self, cond: Location, label: Label) -> 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);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+        Ok(())
+    }
+    fn emit_on_false_label_far(
+        &mut self,
+        cond: Location,
+        label: Label,
+    ) -> 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);
+                } else {
+                    self.emit_j_label(cont)?;
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+
+        dynasm!(self; j => label);
+        self.emit_label(cont)?;
+        Ok(())
+    }
+    fn emit_on_true_label(&mut self, cond: Location, label: Label) -> 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);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to true branch {:?}", cond),
+        }
+        Ok(())
+    }
+    fn emit_on_true_label_far(&mut self, cond: Location, label: Label) -> 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);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit jump to false branch {:?}", cond),
+        }
+
+        // skip over the jump to target
+        dynasm!(self; j => cont);
+
+        self.emit_label(jump_label)?;
+        dynasm!(self; j => label);
+
+        self.emit_label(cont)?;
+
+        Ok(())
+    }
+
+    fn emit_j_label(&mut self, label: Label) -> Result<(), CompileError> {
+        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 4624525f37..31d486dea1 100644
--- a/lib/compiler-singlepass/src/emitter_x64.rs
+++ b/lib/compiler-singlepass/src/emitter_x64.rs
@@ -7,16 +7,15 @@ pub use crate::{
     machine::{Label, Offset},
     x64_decl::{GPR, XMM},
 };
-use dynasm::dynasm;
 use dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi};
-use wasmer_types::{target::CpuFeature, CompileError};
+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
 /// `target_arch`, but it sees the `target_arch` of the proc-macro itself, which
 /// is always equal to host, even when cross-compiling.
 macro_rules! dynasm {
-    ($a:expr ; $($tt:tt)*) => {
+    ($a:expr_2021 ; $($tt:tt)*) => {
         dynasm::dynasm!(
             $a.inner
             ; .arch x64
@@ -169,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,
@@ -187,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,
@@ -445,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,7 +464,7 @@ pub trait EmitterX64 {
 }
 
 macro_rules! unop_gpr {
-    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $loc:expr_2021, $otherwise:block) => {
         match ($sz, $loc) {
             (Size::S32, Location::GPR(loc)) => {
                 dynasm!($assembler ; $ins Rd(loc));
@@ -487,7 +478,7 @@ macro_rules! unop_gpr {
 }
 
 macro_rules! unop_mem {
-    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $loc:expr_2021, $otherwise:block) => {
         match ($sz, $loc) {
             (Size::S32, Location::Memory(loc, disp)) => {
                 dynasm!($assembler ; $ins DWORD [Rq(loc) + disp] );
@@ -501,7 +492,7 @@ macro_rules! unop_mem {
 }
 
 macro_rules! unop_gpr_or_mem {
-    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $loc:expr_2021, $otherwise:block) => {
         unop_gpr!($ins, $assembler, $sz, $loc, {
             unop_mem!($ins, $assembler, $sz, $loc, $otherwise)
         })
@@ -509,7 +500,7 @@ macro_rules! unop_gpr_or_mem {
 }
 
 macro_rules! binop_imm32_gpr {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Imm32(src), Location::GPR(dst)) => {
                 dynasm!($assembler ; $ins Rd(dst), src as i32); // IMM32_2GPR
@@ -523,7 +514,7 @@ macro_rules! binop_imm32_gpr {
 }
 
 macro_rules! binop_imm32_mem {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Imm32(src), Location::Memory(dst, disp)) => {
                 dynasm!($assembler ; $ins DWORD [Rq(dst) + disp], src as i32);
@@ -537,7 +528,7 @@ macro_rules! binop_imm32_mem {
 }
 
 macro_rules! binop_imm64_gpr {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S64, Location::Imm64(src), Location::GPR(dst)) => {
                 dynasm!($assembler ; $ins Rq(dst), QWORD src as i64); // IMM32_2GPR
@@ -548,7 +539,7 @@ macro_rules! binop_imm64_gpr {
 }
 
 macro_rules! binop_gpr_gpr {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
                 dynasm!($assembler ; $ins Rd(dst), Rd(src)); // GPR2GPR
@@ -562,7 +553,7 @@ macro_rules! binop_gpr_gpr {
 }
 
 macro_rules! binop_gpr_mem {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
                 dynasm!($assembler ; $ins [Rq(dst) + disp], Rd(src)); // GPR2MEM
@@ -576,7 +567,7 @@ macro_rules! binop_gpr_mem {
 }
 
 macro_rules! binop_mem_gpr {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
                 dynasm!($assembler ; $ins Rd(dst), [Rq(src) + disp]); // MEM2GPR
@@ -590,7 +581,7 @@ macro_rules! binop_mem_gpr {
 }
 
 macro_rules! binop_all_nofp {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         binop_imm32_gpr!($ins, $assembler, $sz, $src, $dst, {
             binop_imm32_mem!($ins, $assembler, $sz, $src, $dst, {
                 binop_gpr_gpr!($ins, $assembler, $sz, $src, $dst, {
@@ -604,7 +595,7 @@ macro_rules! binop_all_nofp {
 }
 
 macro_rules! binop_shift {
-    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+    ($ins:ident, $assembler:tt, $sz:expr_2021, $src:expr_2021, $dst:expr_2021, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(GPR::RCX), Location::GPR(dst)) => {
                 dynasm!($assembler ; $ins Rd(dst), cl);
@@ -736,7 +727,7 @@ macro_rules! avx_fn {
 }
 
 macro_rules! sse_fn {
-    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $emitter:ident, $precision:expr_2021, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             XMMOrMemory::XMM(x) => {
                 if x == $dst {
@@ -752,7 +743,7 @@ macro_rules! sse_fn {
             }
         }
     };
-    ($ins:ident, $mode:expr, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $mode:expr_2021, $emitter:ident, $precision:expr_2021, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             XMMOrMemory::XMM(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
@@ -810,7 +801,7 @@ macro_rules! avx_i2f_64_fn {
 }
 
 macro_rules! sse_i2f_64_fn {
-    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $emitter:ident, $precision:expr_2021, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             GPROrMemory::GPR(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
@@ -868,7 +859,7 @@ macro_rules! avx_i2f_32_fn {
 }
 
 macro_rules! sse_i2f_32_fn {
-    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $emitter:ident, $precision:expr_2021, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             GPROrMemory::GPR(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
@@ -883,7 +874,7 @@ macro_rules! sse_i2f_32_fn {
 }
 
 macro_rules! avx_round_fn {
-    ($ins:ident, $mode:expr, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $mode:expr_2021, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             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),
@@ -892,7 +883,7 @@ macro_rules! avx_round_fn {
 }
 
 macro_rules! sse_round_fn {
-    ($ins:ident, $mode:expr, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+    ($ins:ident, $mode:expr_2021, $emitter:ident, $precision:expr_2021, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             XMMOrMemory::XMM(x) => {
                 if x != $dst {
@@ -909,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 {
@@ -1259,6 +1250,12 @@ impl EmitterX64 for AssemblerX64 {
         }
         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.
         //
diff --git a/lib/compiler-singlepass/src/lib.rs b/lib/compiler-singlepass/src/lib.rs
index 2ea4cf7262..025c2c0df2 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,21 @@ mod config;
 #[cfg(feature = "unwind")]
 mod dwarf;
 mod emitter_arm64;
+#[cfg(feature = "riscv")]
+mod emitter_riscv;
 mod emitter_x64;
 mod location;
 mod machine;
 mod machine_arm64;
+#[cfg(feature = "riscv")]
+mod machine_riscv;
 mod machine_x64;
+#[cfg(feature = "riscv")]
+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 b1e10fd45e..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,16 +35,25 @@ 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)]
@@ -69,10 +77,6 @@ pub trait Descriptor<R: Reg, S: Reg> {
 
 #[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 1207c5568e..c165f28496 100644
--- a/lib/compiler-singlepass/src/machine.rs
+++ b/lib/compiler-singlepass/src/machine.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "riscv")]
+use crate::machine_riscv::MachineRiscv;
 use crate::{
     common_decl::*,
     location::{Location, Reg},
@@ -5,8 +7,12 @@ use crate::{
     machine_x64::MachineX86_64,
     unwind::UnwindInstructions,
 };
+
 use dynasmrt::{AssemblyOffset, DynamicLabel};
-use std::{collections::BTreeMap, fmt::Debug};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fmt::Debug,
+};
 use wasmer_compiler::{
     types::{
         address_map::InstructionAddressMap,
@@ -14,11 +20,11 @@ use wasmer_compiler::{
         relocation::{Relocation, RelocationTarget},
         section::CustomSection,
     },
-    wasmparser::{MemArg, ValType as WpType},
+    wasmparser::MemArg,
 };
 use wasmer_types::{
-    target::{Architecture, CallingConvention, Target},
     CompileError, FunctionIndex, FunctionType, TrapCode, TrapInformation, VMOffsets,
+    target::{Architecture, CallingConvention, Target},
 };
 pub type Label = DynamicLabel;
 pub type Offset = AssemblyOffset;
@@ -44,6 +50,7 @@ pub trait MaybeImmediate {
     fn is_imm(&self) -> bool {
         self.imm_value().is_some()
     }
+    fn imm_value_scalar(&self) -> Option<i64>;
 }
 
 /// A trap table for a `RunnableModuleInfo`.
@@ -56,7 +63,41 @@ 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 {
@@ -64,10 +105,6 @@ pub trait Machine {
     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.
@@ -90,10 +127,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
@@ -134,15 +171,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,
@@ -178,6 +210,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,
@@ -189,16 +223,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(
@@ -216,14 +264,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,
@@ -237,11 +277,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;
@@ -253,17 +294,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,
@@ -279,14 +311,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,
@@ -297,48 +327,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,
@@ -347,23 +339,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(
@@ -372,35 +347,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,
@@ -442,14 +402,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,
@@ -493,7 +445,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(
@@ -511,7 +462,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(
@@ -520,7 +470,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(
@@ -1180,7 +1129,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(
@@ -1198,7 +1146,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(
@@ -1207,7 +1154,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(
@@ -2422,6 +2368,11 @@ pub fn gen_std_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_std_trampoline(sig, calling_convention)
         }
+        #[cfg(feature = "riscv")]
+        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(),
         )),
@@ -2444,6 +2395,11 @@ pub fn gen_std_dynamic_import_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_std_dynamic_import_trampoline(vmoffsets, sig, calling_convention)
         }
+        #[cfg(feature = "riscv")]
+        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(),
         )),
@@ -2466,6 +2422,11 @@ pub fn gen_import_call_trampoline(
             let machine = MachineARM64::new(Some(target.clone()));
             machine.gen_import_call_trampoline(vmoffsets, index, sig, calling_convention)
         }
+        #[cfg(feature = "riscv")]
+        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 e3b42c9360..61a7d9f7e8 100644
--- a/lib/compiler-singlepass/src/machine_arm64.rs
+++ b/lib/compiler-singlepass/src/machine_arm64.rs
@@ -1,6 +1,8 @@
-use dynasmrt::{aarch64::Aarch64Relocation, VecAssembler};
+use std::collections::HashMap;
+
+use dynasmrt::{VecAssembler, aarch64::Aarch64Relocation};
 #[cfg(feature = "unwind")]
-use gimli::{write::CallFrameInstruction, AArch64};
+use gimli::{AArch64, write::CallFrameInstruction};
 
 use wasmer_compiler::{
     types::{
@@ -9,103 +11,26 @@ use wasmer_compiler::{
         relocation::{Relocation, RelocationKind, RelocationTarget},
         section::CustomSection,
     },
-    wasmparser::{MemArg, ValType as WpType},
+    wasmparser::MemArg,
 };
 use wasmer_types::{
-    target::{CallingConvention, CpuFeature, Target},
     CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, VMOffsets,
+    target::{CallingConvention, CpuFeature, Target},
 };
 
 use crate::{
-    arm64_decl::{new_machine_state, GPR, NEON},
+    arm64_decl::{GPR, NEON},
     codegen_error,
     common_decl::*,
     emitter_arm64::*,
     location::{Location as AbstractLocation, Reg},
     machine::*,
-    unwind::{UnwindInstructions, UnwindOps},
+    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,
@@ -119,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 {
@@ -573,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)?;
@@ -1134,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;
         }
@@ -1254,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(())
     }
@@ -1410,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> {
@@ -1424,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
@@ -1501,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() {
@@ -1556,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(
@@ -1580,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
@@ -1655,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
@@ -1667,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 {
@@ -1684,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 {
@@ -1701,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,
@@ -1802,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,
             }),
             _ => (),
@@ -1819,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,
@@ -1827,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,
@@ -2170,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,
@@ -2301,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,
         })
     }
 
@@ -2325,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
@@ -2360,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,
@@ -2450,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> {
@@ -2459,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,
@@ -2490,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),
@@ -2501,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,
@@ -2570,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,
@@ -2601,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
@@ -2668,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())
@@ -2712,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,
@@ -2809,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)?;
@@ -2876,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)?;
@@ -2914,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)?;
@@ -4955,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)?;
@@ -5022,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)?;
@@ -5060,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)?;
@@ -7616,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,
@@ -7672,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,
@@ -8543,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 => {
@@ -8558,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..4059ac5ad1
--- /dev/null
+++ b/lib/compiler-singlepass/src/machine_riscv.rs
@@ -0,0 +1,6237 @@
+//! RISC-V machine scaffolding.
+
+use dynasmrt::{DynasmError, VecAssembler, riscv::RiscvRelocation};
+#[cfg(feature = "unwind")]
+use gimli::{RiscV, write::CallFrameInstruction};
+
+use wasmer_compiler::{
+    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;
+const CANONICAL_NAN_F64: u64 = 0x7ff8000000000000;
+const CANONICAL_NAN_F32: u32 = 0x7fc00000;
+
+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())
+                        })?;
+
+                        // 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)?;
+                        self.assembler
+                            .emit_on_true_label(Location::GPR(tmp), label_retry)?;
+
+                        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");
+        };
+
+        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)?;
+                self.assembler.emit_reserved_sd(size, cond, addr, new)?;
+                self.assembler
+                    .emit_on_true_label(Location::GPR(cond), label_retry)?;
+
+                // 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)?;
+
+                // 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)?;
+
+                // 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);
+
+            // 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)?;
+
+            self.assembler
+                .emit_fcmp(Condition::Eq, sz, src2, src2, Location::GPR(tmp))?;
+            self.assembler
+                .emit_on_false_label(Location::GPR(tmp), label_after)?;
+        }
+
+        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))?;
+
+        // 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)?;
+            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)?;
+
+        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)?;
+        }
+        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(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),
+        )?;
+        self.assembler
+            .emit_on_true_label(Location::GPR(tmp_cond), label_unaligned)?;
+        // 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),
+        )?;
+        self.assembler
+            .emit_on_true_label(Location::GPR(tmp_cond), label_unaligned)?;
+        // 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))?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(arg), label_exit)?;
+        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();
+
+        // 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)?;
+
+        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)?;
+
+        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();
+
+        // 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)?;
+
+        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)?;
+
+        self.assembler
+            .emit_add(sz, Location::GPR(cnt), one_imm, Location::GPR(cnt))?;
+        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))?;
+            self.assembler
+                .emit_on_false_label(Location::GPR(cond), end)?;
+            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),
+        )?;
+        self.assembler
+            .emit_on_false_label(Location::GPR(fscr), end)?;
+
+        // 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)?;
+        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!(),
+        };
+
+        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)?;
+
+        // 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)?;
+
+        // 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(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),
+        )?;
+        self.assembler.emit_on_true_label(cnt, label)?;
+        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> {
+        self.assembler.emit_j_label(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> {
+        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)?;
+        }
+
+        self.assembler
+            .emit_jmp_on_condition(c, loc_a, loc_b, label)?;
+
+        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 4 (size of each instruction)
+        self.assembler.emit_sll(
+            Size::S32,
+            Location::GPR(tmp2),
+            Location::Imm32(2),
+            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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+        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)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+        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)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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)?;
+
+        self.assembler
+            .emit_on_false_label_far(src2, integer_division_by_zero)?;
+        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 1c7530607c..eaabce6079 100644
--- a/lib/compiler-singlepass/src/machine_x64.rs
+++ b/lib/compiler-singlepass/src/machine_x64.rs
@@ -6,13 +6,16 @@ use crate::{
     emitter_x64::*,
     location::{Location as AbstractLocation, Reg},
     machine::*,
-    unwind::{UnwindInstructions, UnwindOps},
-    x64_decl::{new_machine_state, ArgumentRegisterAllocator, X64Register, GPR, XMM},
+    unwind::{UnwindInstructions, UnwindOps, UnwindRegister},
+    x64_decl::{ArgumentRegisterAllocator, GPR, X64Register, XMM},
 };
-use dynasmrt::{x64::X64Relocation, DynasmError, VecAssembler};
+use dynasmrt::{DynasmError, VecAssembler, x64::X64Relocation};
 #[cfg(feature = "unwind")]
-use gimli::{write::CallFrameInstruction, X86_64};
-use std::ops::{Deref, DerefMut};
+use gimli::{X86_64, write::CallFrameInstruction};
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+};
 use wasmer_compiler::{
     types::{
         address_map::InstructionAddressMap,
@@ -20,12 +23,12 @@ use wasmer_compiler::{
         relocation::{Relocation, RelocationKind, RelocationTarget},
         section::{CustomSection, CustomSectionProtection, SectionBody},
     },
-    wasmparser::{MemArg, ValType as WpType},
+    wasmparser::MemArg,
 };
 use wasmer_types::{
-    target::{CallingConvention, CpuFeature, Target},
     CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, Type,
     VMOffsets,
+    target::{CallingConvention, CpuFeature, Target},
 };
 
 type Assembler = VecAssembler<X64Relocation>;
@@ -35,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),
@@ -85,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,
@@ -142,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)?;
@@ -682,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);
@@ -1923,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(())
     }
@@ -1931,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 {
@@ -1939,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
@@ -1966,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);
@@ -1978,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);
@@ -2065,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(
@@ -2162,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,
@@ -2246,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(()),
@@ -2267,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,
@@ -2275,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,
@@ -2433,7 +2476,9 @@ impl Machine for MachineX86_64 {
                     }
                 }
             },
-            _ => panic!(                "unimplemented move_location_extend({size_val:?}, {signed}, {source:?}, {size_op:?}, {dest:?}"            ),
+            _ => panic!(
+                "unimplemented move_location_extend({size_val:?}, {signed}, {source:?}, {size_op:?}, {dest:?}"
+            ),
         }?;
         if dst != dest {
             self.assembler.emit_mov(size_op, dst, dest)?;
@@ -2444,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,
@@ -2497,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,
         })
     }
 
@@ -2530,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,
@@ -2559,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,
@@ -2644,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> {
@@ -2653,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,
@@ -2679,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,
@@ -2734,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,
@@ -2751,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
@@ -2830,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),
@@ -2868,20 +2794,8 @@ 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(
+
+    fn emit_relaxed_sign_extension(
         &mut self,
         sz_src: Size,
         src: Location,
@@ -2921,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
@@ -2966,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
@@ -2989,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();
@@ -4590,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
@@ -4635,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
@@ -4658,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();
@@ -6661,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,
@@ -6729,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,
@@ -7157,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,
@@ -7284,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,
@@ -7555,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,
@@ -7682,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,
@@ -7839,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,
@@ -7872,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))?;
@@ -7902,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"),
                 }
             }
         }
@@ -7915,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,
@@ -7922,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))?;
@@ -7939,6 +7835,7 @@ impl Machine for MachineX86_64 {
 
         let mut body = a.finalize().unwrap();
         body.shrink_to_fit();
+
         Ok(FunctionBody {
             body,
             unwind_info: None,
@@ -8264,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 {
diff --git a/lib/compiler-singlepass/src/riscv_decl.rs b/lib/compiler-singlepass/src/riscv_decl.rs
new file mode 100644
index 0000000000..3108536974
--- /dev/null
+++ b/lib/compiler-singlepass/src/riscv_decl.rs
@@ -0,0 +1,436 @@
+//! 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()
+    }
+    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()
+    }
+
+    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 babff85afb..b6ec3a3ecd 100644
--- a/lib/compiler-singlepass/src/unwind.rs
+++ b/lib/compiler-singlepass/src/unwind.rs
@@ -6,12 +6,44 @@ use std::fmt::Debug;
 #[cfg(feature = "unwind")]
 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 979e740644..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;
@@ -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 9edd43a86e..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::{target::CallingConvention, CompileError, Type};
+use wasmer_types::{CompileError, Type, target::CallingConvention};
 
 /// General-purpose registers.
 #[repr(u8)]
@@ -66,16 +64,6 @@ impl From<XMM> for u8 {
 }
 
 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
-    }
     fn into_index(self) -> usize {
         self as usize
     }
@@ -106,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
     }
@@ -169,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,
+        }
     }
 }
 
@@ -184,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())
@@ -199,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
@@ -232,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.
@@ -301,7 +270,7 @@ impl ArgumentRegisterAllocator {
                     _ => {
                         return Err(CompileError::Codegen(format!(
                             "No register available for {calling_convention:?} and type {ty}"
-                        )))
+                        )));
                     }
                 }
             }
@@ -340,7 +309,7 @@ impl ArgumentRegisterAllocator {
                     _ => {
                         return Err(CompileError::Codegen(format!(
                             "No register available for {calling_convention:?} and type {ty}"
-                        )))
+                        )));
                     }
                 }
             }
@@ -349,14 +318,3 @@ impl ArgumentRegisterAllocator {
         Ok(ret)
     }
 }
-
-/// 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: usize::MAX,
-    }
-}
diff --git a/lib/compiler/Cargo.toml b/lib/compiler/Cargo.toml
index 391bf8b9e3..91de196875 100644
--- a/lib/compiler/Cargo.toml
+++ b/lib/compiler/Cargo.toml
@@ -14,14 +14,14 @@ version.workspace = true
 
 [dependencies]
 wasmer-types = { path = "../types", version = "=6.1.0", default-features = false }
-wasmparser = { workspace = true, optional = true, default-features = false }
+wasmparser = { workspace = true, default-features = false, optional = true }
 enumset.workspace = true
 hashbrown = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 thiserror.workspace = true
 serde_bytes = { workspace = true, optional = true }
 smallvec.workspace = true
-xxhash-rust = { version = "0.8.10", features = ["xxh64"] }
+xxhash-rust = { workspace = true, features = ["xxh64"] }
 loupe = { workspace = true, optional = true, features = [
 	"indexmap",
 	"enable-indexmap",
@@ -32,28 +32,31 @@ memmap2.workspace = true
 more-asserts.workspace = true
 
 cfg-if.workspace = true
-leb128 = "0.2"
+leb128.workspace = true
 enum-iterator.workspace = true
 
 bytes.workspace = true
-self_cell = "1.0"
+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
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 wasmer-vm = { path = "../vm", version = "=6.1.0" }
 region.workspace = true
+which = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.59", features = [
+windows-sys = { workspace = true, features = [
 	"Win32_System_Diagnostics_Debug",
 ] }
 
 [target.'cfg(all(target_os = "macos", target_arch = "aarch64"))'.dependencies]
-macho-unwind-info = "0.5.0"
+macho-unwind-info.workspace = true
 
 [features]
 default = ["std"]
diff --git a/lib/compiler/src/artifact_builders/artifact_builder.rs b/lib/compiler/src/artifact_builders/artifact_builder.rs
index 20470eeb53..8d607b02e5 100644
--- a/lib/compiler/src/artifact_builders/artifact_builder.rs
+++ b/lib/compiler/src/artifact_builders/artifact_builder.rs
@@ -4,22 +4,22 @@
 #[cfg(feature = "compiler")]
 use super::trampoline::{libcall_trampoline_len, make_libcall_trampolines};
 
-#[cfg(feature = "compiler")]
-use crate::{
-    serialize::SerializableCompilation, EngineInner, ModuleEnvironment, ModuleMiddlewareChain,
-};
 use crate::{
+    ArtifactCreate, Features,
     serialize::{
         ArchivedSerializableCompilation, ArchivedSerializableModule, MetadataHeader,
         SerializableModule,
     },
     types::{
-        function::{CompiledFunctionFrameInfo, FunctionBody, UnwindInfo, GOT},
+        function::{CompiledFunctionFrameInfo, FunctionBody, GOT, UnwindInfo},
         module::CompileModuleInfo,
         relocation::Relocation,
         section::{CustomSection, SectionIndex},
     },
-    ArtifactCreate, Features,
+};
+#[cfg(feature = "compiler")]
+use crate::{
+    EngineInner, ModuleEnvironment, ModuleMiddlewareChain, serialize::SerializableCompilation,
 };
 #[cfg(feature = "compiler")]
 use wasmer_types::target::Target;
@@ -31,9 +31,9 @@ use self_cell::self_cell;
 use shared_buffer::OwnedBuffer;
 use std::sync::Arc;
 use wasmer_types::{
+    DeserializeError,
     entity::{ArchivedPrimaryMap, PrimaryMap},
     target::CpuFeature,
-    DeserializeError,
 };
 
 // Not every compiler backend uses these.
diff --git a/lib/compiler/src/artifact_builders/trampoline.rs b/lib/compiler/src/artifact_builders/trampoline.rs
index 39d021bb68..4363386cfa 100644
--- a/lib/compiler/src/artifact_builders/trampoline.rs
+++ b/lib/compiler/src/artifact_builders/trampoline.rs
@@ -5,9 +5,8 @@
 
 #![cfg_attr(not(feature = "compiler"), allow(dead_code))]
 
-use enum_iterator::IntoEnumIterator;
-use wasmer_types::target::{Architecture, Target};
 use wasmer_types::LibCall;
+use wasmer_types::target::{Architecture, Target};
 
 use crate::types::{
     relocation::{Relocation, RelocationKind, RelocationTarget},
@@ -112,7 +111,7 @@ 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 {
diff --git a/lib/compiler/src/compiler.rs b/lib/compiler/src/compiler.rs
index 82d3976c7d..43fb8685ae 100644
--- a/lib/compiler/src/compiler.rs
+++ b/lib/compiler/src/compiler.rs
@@ -3,17 +3,17 @@
 
 use crate::types::{module::CompileModuleInfo, symbols::SymbolRegistry};
 use crate::{
+    FunctionBodyData, ModuleTranslationState,
     lib::std::{boxed::Box, sync::Arc},
     translator::ModuleMiddleware,
     types::function::Compilation,
-    FunctionBodyData, ModuleTranslationState,
 };
 use enumset::EnumSet;
 use wasmer_types::{
+    Features, LocalFunctionIndex,
     entity::PrimaryMap,
     error::CompileError,
     target::{CpuFeature, Target, UserCompilerOptimizations},
-    Features, LocalFunctionIndex,
 };
 #[cfg(feature = "translator")]
 use wasmparser::{Validator, WasmFeatures};
diff --git a/lib/compiler/src/engine/artifact.rs b/lib/compiler/src/engine/artifact.rs
index faeeaea2fe..23a8be9fde 100644
--- a/lib/compiler/src/engine/artifact.rs
+++ b/lib/compiler/src/engine/artifact.rs
@@ -2,25 +2,25 @@
 //! to allow compiling and instantiating to be done as separate steps.
 
 use std::sync::{
-    atomic::{AtomicUsize, Ordering::SeqCst},
     Arc,
+    atomic::{AtomicUsize, Ordering::SeqCst},
 };
 
 #[cfg(feature = "compiler")]
 use crate::ModuleEnvironment;
 use crate::{
+    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},
-    ArtifactBuild, ArtifactBuildFromArchive, ArtifactCreate, Engine, EngineInner, Features,
-    FrameInfosVariant, FunctionExtent, GlobalFrameInfoRegistration, InstantiationError, Tunables,
 };
+#[cfg(feature = "static-artifact-create")]
+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};
-#[cfg(feature = "static-artifact-create")]
-use crate::{types::module::CompileModuleInfo, Compiler, FunctionBodyData, ModuleTranslationState};
 
 use enumset::EnumSet;
 use shared_buffer::OwnedBuffer;
@@ -30,18 +30,18 @@ use std::mem;
 
 #[cfg(feature = "static-artifact-create")]
 use crate::object::{
-    emit_compilation, emit_data, get_object_for_target, Object, ObjectMetadataBuilder,
+    Object, ObjectMetadataBuilder, emit_compilation, emit_data, get_object_for_target,
 };
 
 #[cfg(feature = "compiler")]
 use wasmer_types::HashAlgorithm;
 use wasmer_types::{
-    entity::{BoxedSlice, PrimaryMap},
-    target::{CpuFeature, Target},
     ArchivedDataInitializerLocation, ArchivedOwnedDataInitializer, CompileError, DataInitializer,
     DataInitializerLike, DataInitializerLocation, DataInitializerLocationLike, DeserializeError,
     FunctionIndex, LocalFunctionIndex, MemoryIndex, ModuleInfo, OwnedDataInitializer,
     SerializeError, SignatureIndex, TableIndex,
+    entity::{BoxedSlice, PrimaryMap},
+    target::{CpuFeature, Target},
 };
 
 use wasmer_vm::{
@@ -208,37 +208,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(e) => {
-                    return Err(DeserializeError::Incompatible(format!(
-                        "The provided bytes are not wasmer-universal: {e}"
-                    )));
+        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.
@@ -253,37 +255,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(e) => {
-                    return Err(DeserializeError::Incompatible(format!(
-                        "The provided bytes are not wasmer-universal: {e}"
-                    )));
+        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.
@@ -332,7 +336,7 @@ impl Artifact {
         };
 
         let get_got_address: Box<dyn Fn(RelocationTarget) -> Option<usize>> = match &artifact {
-            ArtifactBuildVariant::Plain(ref p) => {
+            ArtifactBuildVariant::Plain(p) => {
                 if let Some(got) = p.get_got_ref().index {
                     let relocs: Vec<_> = p.get_custom_section_relocations_ref()[got]
                         .iter()
@@ -350,7 +354,7 @@ impl Artifact {
                 }
             }
 
-            ArtifactBuildVariant::Archived(ref p) => {
+            ArtifactBuildVariant::Archived(p) => {
                 if let Some(got) = p.get_got_ref().index {
                     let relocs: Vec<_> = p.get_custom_section_relocations_ref()[got]
                         .iter()
@@ -373,6 +377,7 @@ impl 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())),
@@ -387,6 +392,7 @@ impl Artifact {
             ArtifactBuildVariant::Archived(a) => link_module(
                 module_info,
                 &finished_functions,
+                &finished_dynamic_function_trampolines,
                 a.get_function_relocations()
                     .iter()
                     .map(|(k, v)| (k, v.iter())),
@@ -448,7 +454,7 @@ impl Artifact {
             get_got_address(RelocationTarget::LibCall(wasmer_vm::LibCall::EHPersonality)),
         )?;
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
         {
             engine_inner.register_perfmap(&finished_functions, module_info)?;
         }
@@ -832,75 +838,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)
-            )));
-        }
-
-        self.preinstantiate()?;
-
-        let module = self.create_module_info();
+        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)
+                )));
+            }
 
-        let tags = resolve_tags(&module, imports, context).map_err(InstantiationError::Link)?;
+            self.preinstantiate()?;
 
-        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,
-            tags,
-            imports,
-            self.signatures().clone(),
-        )
-        .map_err(InstantiationError::Start)?;
-        Ok(handle)
+            .map_err(InstantiationError::Start)?;
+            Ok(handle)
+        }
     }
 
     /// Finishes the instantiation of a just created `VMInstance`.
@@ -915,16 +923,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)]
@@ -1101,7 +1111,7 @@ impl Artifact {
             target_lexicon::Architecture::Aarch64(_) => {
                 if matches!(
                     target_triple.operating_system,
-                    target_lexicon::OperatingSystem::Darwin
+                    target_lexicon::OperatingSystem::Darwin(_)
                 ) {
                     8
                 } else {
@@ -1172,114 +1182,119 @@ impl Artifact {
         engine: &Engine,
         bytes: OwnedBuffer,
     ) -> Result<Self, DeserializeError> {
-        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 trampolines in order
-        let mut finished_function_call_trampolines = PrimaryMap::new();
+            // 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);
+            }
+
+            // 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 c4d56c0a20..5c802ae39c 100644
--- a/lib/compiler/src/engine/builder.rs
+++ b/lib/compiler/src/engine/builder.rs
@@ -1,7 +1,7 @@
 use super::Engine;
 #[cfg(feature = "compiler")]
 use crate::CompilerConfig;
-use wasmer_types::{target::Target, Features, HashAlgorithm};
+use wasmer_types::{Features, HashAlgorithm, target::Target};
 
 /// The Builder contents of `Engine`
 pub struct EngineBuilder {
diff --git a/lib/compiler/src/engine/code_memory.rs b/lib/compiler/src/engine/code_memory.rs
index a4ab625d9d..d781ae6dac 100644
--- a/lib/compiler/src/engine/code_memory.rs
+++ b/lib/compiler/src/engine/code_memory.rs
@@ -4,12 +4,12 @@
 //! Memory management for executable code.
 use super::unwind::UnwindRegistry;
 use crate::{
+    GlobalFrameInfoRegistration,
     types::{
         function::FunctionBodyLike,
         section::CustomSectionLike,
         unwind::{CompiledFunctionUnwindInfoLike, CompiledFunctionUnwindInfoReference},
     },
-    GlobalFrameInfoRegistration,
 };
 use wasmer_vm::{Mmap, VMFunctionBody};
 
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 8d1637fbad..62355ed5df 100644
--- a/lib/compiler/src/engine/inner.rs
+++ b/lib/compiler/src/engine/inner.rs
@@ -1,36 +1,38 @@
 //! 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::{
-    types::{
-        function::FunctionBodyLike,
-        section::{CustomSectionLike, CustomSectionProtection, SectionIndex},
-    },
-    Artifact, BaseTunables, CodeMemory, FunctionExtent, GlobalFrameInfoRegistration, Tunables,
-};
 #[cfg(feature = "compiler")]
 use crate::{Compiler, CompilerConfig};
 
+#[cfg(feature = "compiler")]
+use wasmer_types::Features;
+use wasmer_types::{CompileError, HashAlgorithm, 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::{Arc, Mutex};
-use std::{
-    io::Write,
-    sync::atomic::{AtomicUsize, Ordering::SeqCst},
+#[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
+use wasmer_types::ModuleInfo;
+#[cfg(not(target_arch = "wasm32"))]
+use wasmer_types::{
+    DeserializeError, FunctionIndex, FunctionType, LocalFunctionIndex, SignatureIndex,
+    entity::PrimaryMap,
 };
 
-#[cfg(feature = "compiler")]
-use wasmer_types::Features;
 #[cfg(not(target_arch = "wasm32"))]
-use wasmer_types::{
-    entity::PrimaryMap, DeserializeError, FunctionIndex, FunctionType, LocalFunctionIndex,
-    SignatureIndex,
+use crate::{
+    Artifact, BaseTunables, CodeMemory, FunctionExtent, GlobalFrameInfoRegistration, Tunables,
+    types::{
+        function::FunctionBodyLike,
+        section::{CustomSectionLike, CustomSectionProtection, SectionIndex},
+    },
 };
-use wasmer_types::{target::Target, CompileError, HashAlgorithm, ModuleInfo};
 
 #[cfg(not(target_arch = "wasm32"))]
 use wasmer_vm::{
@@ -98,9 +100,9 @@ impl Engine {
 
     /// Returns the deterministic id of this engine
     pub fn deterministic_id(&self) -> String {
-        let i = self.inner();
         #[cfg(feature = "compiler")]
         {
+            let i = self.inner();
             if let Some(ref c) = i.compiler {
                 return c.deterministic_id();
             } else {
@@ -213,7 +215,7 @@ impl Engine {
 
     #[cfg(not(target_arch = "wasm32"))]
     /// Deserializes a WebAssembly module which was previously serialized with
-    /// [`Module::serialize`].
+    /// [`wasmer::Module::serialize`].
     ///
     /// # Safety
     ///
@@ -222,11 +224,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
     ///
@@ -236,7 +238,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.
@@ -248,10 +250,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.
@@ -264,10 +269,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.
@@ -305,13 +313,13 @@ impl Engine {
     /// more optimizations.
     pub fn with_opts(
         &mut self,
-        suggested_opts: &wasmer_types::target::UserCompilerOptimizations,
+        _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)?;
+                c.with_opts(_suggested_opts)?;
             }
         }
 
@@ -536,7 +544,7 @@ impl EngineInner {
             .register_frame_info(frame_info);
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_arch = "wasm32"), feature = "compiler"))]
     pub(crate) fn register_perfmap(
         &self,
         finished_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
diff --git a/lib/compiler/src/engine/link.rs b/lib/compiler/src/engine/link.rs
index fd6c7ae63d..1fd251828f 100644
--- a/lib/compiler/src/engine/link.rs
+++ b/lib/compiler/src/engine/link.rs
@@ -1,26 +1,26 @@
 //! Linking for Universal-compiled code.
 
 use crate::{
-    get_libcall_trampoline,
+    FunctionExtent, get_libcall_trampoline,
     types::{
         relocation::{RelocationKind, RelocationLike, RelocationTarget},
         section::SectionIndex,
     },
-    FunctionExtent,
 };
 use std::{
     collections::{HashMap, HashSet},
     ptr::{read_unaligned, write_unaligned},
 };
 
-use wasmer_types::{entity::PrimaryMap, LocalFunctionIndex, ModuleInfo};
-use wasmer_vm::{libcalls::function_pointer, SectionBodyPtr};
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, ModuleInfo, entity::PrimaryMap};
+use wasmer_vm::{FunctionBodyPtr, SectionBodyPtr, libcalls::function_pointer};
 
 #[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_sec_idx: SectionIndex,
     libcall_trampoline_len: usize,
@@ -42,6 +42,9 @@ fn apply_relocation(
     } 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.
@@ -342,7 +345,8 @@ fn apply_relocation(
                 let raw_instr = read_unaligned(fixup_ptr as *mut u32);
 
                 assert_eq!(
-                    raw_instr & 0xfffffc00, 0xf9400000,
+                    raw_instr & 0xfffffc00,
+                    0xf9400000,
                     "raw_instr isn't a 64-bit LDR immediate (bits: {raw_instr:032b}, hex: {raw_instr:x})"
                 );
 
@@ -408,6 +412,7 @@ fn apply_relocation(
 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,
@@ -434,6 +439,7 @@ pub fn link_module<'a>(
                 body,
                 r,
                 allocated_functions,
+                allocated_dynamic_function_trampolines,
                 allocated_sections,
                 libcall_trampolines,
                 trampoline_len,
@@ -449,6 +455,7 @@ pub fn link_module<'a>(
                 body,
                 r,
                 allocated_functions,
+                allocated_dynamic_function_trampolines,
                 allocated_sections,
                 libcall_trampolines,
                 trampoline_len,
diff --git a/lib/compiler/src/engine/resolver.rs b/lib/compiler/src/engine/resolver.rs
index 0630cbe0df..86b81bbfd7 100644
--- a/lib/compiler/src/engine/resolver.rs
+++ b/lib/compiler/src/engine/resolver.rs
@@ -2,14 +2,14 @@
 
 use crate::LinkError;
 use more_asserts::assert_ge;
-use wasmer_types::{
-    entity::{BoxedSlice, EntityRef, PrimaryMap},
-    TagIndex, TagKind,
-};
 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, InternalStoreHandle, LinearMemory, MemoryStyle, StoreObjects,
diff --git a/lib/compiler/src/engine/trap/frame_info.rs b/lib/compiler/src/engine/trap/frame_info.rs
index 2edfbf28dd..abee089e3c 100644
--- a/lib/compiler/src/engine/trap/frame_info.rs
+++ b/lib/compiler/src/engine/trap/frame_info.rs
@@ -12,19 +12,19 @@
 //! FRAME_INFO.register(module, compiled_functions);
 //! ```
 
+use crate::ArtifactBuildFromArchive;
 use crate::types::address_map::{
     ArchivedFunctionAddressMap, ArchivedInstructionAddressMap, FunctionAddressMap,
     InstructionAddressMap,
 };
 use crate::types::function::{ArchivedCompiledFunctionFrameInfo, CompiledFunctionFrameInfo};
-use crate::ArtifactBuildFromArchive;
 use rkyv::vec::ArchivedVec;
 use std::collections::BTreeMap;
 use std::sync::{Arc, LazyLock, RwLock};
 use wasmer_types::lib::std::{cmp, ops::Deref};
 use wasmer_types::{
-    entity::{BoxedSlice, EntityRef, PrimaryMap},
     FrameInfo, LocalFunctionIndex, ModuleInfo, SourceLoc, TrapInformation,
+    entity::{BoxedSlice, EntityRef, PrimaryMap},
 };
 use wasmer_vm::FunctionBodyPtr;
 
@@ -70,7 +70,7 @@ impl ModuleInfoFrameInfo {
     fn function_debug_info(
         &self,
         local_index: LocalFunctionIndex,
-    ) -> CompiledFunctionFrameInfoVariant {
+    ) -> CompiledFunctionFrameInfoVariant<'_> {
         self.frame_infos.get(local_index).unwrap()
     }
 
@@ -202,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
@@ -236,7 +236,7 @@ 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)
@@ -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)
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..bb05d56a1e 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};
+use std::sync::atomic::Ordering;
+
+#[cfg(unix)]
+use crate::engine::unwind::EXIT_CALLED;
+
+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 3fc102316d..a37dd3eed3 100644
--- a/lib/compiler/src/engine/tunables.rs
+++ b/lib/compiler/src/engine/tunables.rs
@@ -1,10 +1,10 @@
 use crate::engine::error::LinkError;
 use std::ptr::NonNull;
 use wasmer_types::{
-    entity::{EntityRef, PrimaryMap},
-    target::{PointerWidth, 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, VMTag};
 use wasmer_vm::{MemoryStyle, TableStyle};
@@ -74,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.
@@ -108,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,
@@ -266,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`].
@@ -285,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) }
     }
 }
 
@@ -312,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> {
@@ -326,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)
+        }
     }
 }
 
@@ -354,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> {
@@ -368,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 d7a5add4d9..91ede6e18b 100644
--- a/lib/compiler/src/engine/unwind/systemv.rs
+++ b/lib/compiler/src/engine/unwind/systemv.rs
@@ -3,7 +3,11 @@
 
 //! 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 crate::types::unwind::CompiledFunctionUnwindInfoReference;
 
@@ -15,7 +19,7 @@ pub struct UnwindRegistry {
     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);
@@ -41,6 +45,7 @@ mod compact_unwind;
 /// 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);
 
@@ -53,6 +58,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
@@ -138,70 +149,88 @@ impl UnwindRegistry {
 
     #[allow(clippy::cast_ptr_alignment)]
     unsafe fn register_frames(&mut self, eh_frame: &[u8]) {
+        // 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"
+        );
+
         #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
         {
             // Special call for macOS on aarch64 to register the `.eh_frame` section.
             // TODO: I am not 100% sure if it's correct to never deregister the `.eh_frame` section. It was this way before
             // I started working on this, so I kept it that way.
-            compact_unwind::__unw_add_dynamic_eh_frame_section(eh_frame.as_ptr() as usize);
-            return;
+            unsafe {
+                compact_unwind::__unw_add_dynamic_eh_frame_section(eh_frame.as_ptr() as usize);
+            }
         }
 
-        // 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.
-
-        // Pointers to the registrations that will be registered with `__register_frame`.
-        // For libgcc based systems, these are CIEs.
-        // For libunwind based systems, these are FDEs.
-        let mut records_to_register = Vec::new();
-
-        let mut current = 0;
-        let mut last_len = 0;
-        while current <= (eh_frame.len() - size_of::<u32>()) {
-            // If a CFI or a FDE starts with 0u32 it is a terminator.
-            let len = u32::from_ne_bytes(eh_frame[current..(current + 4)].try_into().unwrap());
-            if len == 0 {
-                current += size_of::<u32>();
-                last_len = 0;
-                continue;
-            }
-            // The first record after a terminator is always a CIE.
-            let is_cie = last_len == 0;
-            last_len = len;
-            let record = eh_frame.as_ptr() as usize + current;
-            current = current + len as usize + 4;
-
-            if using_libunwind() {
-                // For libunwind based systems, `__register_frame` takes a pointer to an FDE.
-                if !is_cie {
-                    // Every record that's not a CIE is an FDE.
-                    records_to_register.push(record);
+        #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+        {
+            // 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.
+
+            // 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;
                 }
-                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;
 
-            // For libgcc based systems, `__register_frame` takes a pointer to a CIE.
-            if is_cie {
-                records_to_register.push(record);
+                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);
+                    }
+                }
             }
-        }
 
-        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",
-        );
+            assert_eq!(
+                last_len, 0,
+                "The last record in the `.eh_frame` must be a terminator (but it actually has length {last_len})"
+            );
+            assert_eq!(
+                current,
+                eh_frame.len(),
+                "The `.eh_frame` must be finished after the last record",
+            );
 
-        for record in records_to_register {
-            // Register the CFI with libgcc
-            __register_frame(record as *const u8);
-            self.registrations.push(record);
+            for record in records_to_register {
+                // Register the CFI with libgcc
+                unsafe {
+                    __register_frame(record as *const u8);
+                }
+                self.registrations.push(record);
+            }
         }
     }
 
@@ -230,6 +259,16 @@ impl UnwindRegistry {
     }
 }
 
+/// 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 {
@@ -243,6 +282,13 @@ impl Drop for UnwindRegistry {
                 // To ensure that we just pop off the first element in the list upon every
                 // deregistration, walk our list of registrations backwards.
                 for 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;
+                    }
+
                     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
                     {
                         compact_unwind::__unw_remove_dynamic_eh_frame_section(*registration);
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
index 5967a7bdaf..667ff7b110 100644
--- a/lib/compiler/src/engine/unwind/systemv/compact_unwind/cu_entry.rs
+++ b/lib/compiler/src/engine/unwind/systemv/compact_unwind/cu_entry.rs
@@ -50,11 +50,11 @@ impl CompactUnwindEntry {
 
     pub unsafe fn from_ptr_and_len(ptr: *const u8, len: usize) -> Self {
         let mut reader = CompactUnwindEntryReader::new(ptr, len);
-        let function_addr = reader.read::<usize>();
-        let length = reader.read::<u32>();
-        let compact_encoding = reader.read::<u32>();
-        let personality_addr = reader.read::<usize>();
-        let lsda_addr = reader.read::<usize>();
+        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,
diff --git a/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs b/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
index 22805b1254..93add61ed4 100644
--- a/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
+++ b/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
@@ -51,7 +51,7 @@ pub struct UnwDynamicUnwindSections {
 type UnwFindDynamicUnwindSections =
     unsafe extern "C" fn(addr: usize, info: *mut UnwDynamicUnwindSections) -> u32;
 
-extern "C" {
+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
@@ -77,7 +77,6 @@ extern "C" {
 
     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 {
@@ -118,44 +117,48 @@ struct UnwindInfoEntry {
     section_len: usize,
 }
 
+fn reset_unwind_sections(info: &mut UnwDynamicUnwindSections) {
+    info.compact_unwind_section = 0;
+    info.compact_unwind_section_length = 0;
+    info.dwarf_section = 0;
+    info.dwarf_section_length = 0;
+    info.dso_base = 0;
+}
+
 unsafe extern "C" fn find_dynamic_unwind_sections(
     addr: usize,
     info: *mut UnwDynamicUnwindSections,
 ) -> u32 {
-    unsafe {
-        if let Ok(uw_info) = UNWIND_INFO.try_lock() {
-            if uw_info.is_none() {
-                (*info).compact_unwind_section = 0;
-                (*info).compact_unwind_section_length = 0;
-                (*info).dwarf_section = 0;
-                (*info).dwarf_section_length = 0;
-                (*info).dso_base = 0;
-
-                return 0;
-            }
-
-            let uw_info = uw_info.as_ref().unwrap();
-
-            for (range, u) in uw_info.iter() {
+    let Some(info) = (unsafe { info.as_mut() }) else {
+        return 0;
+    };
+
+    // TODO: refactor to not use static mut
+    #[allow(
+        static_mut_refs,
+        reason = "existing behaviour that was disallowed by edition 2024"
+    )]
+    let guard_result = unsafe { UNWIND_INFO.try_lock() };
+    if let Ok(uw_info_guard) = guard_result {
+        if let Some(uw_info) = uw_info_guard.as_ref() {
+            for (range, entry) in uw_info.iter() {
                 if range.contains(&addr) {
-                    (*info).compact_unwind_section = u.section_ptr as _;
-                    (*info).compact_unwind_section_length = u.section_len as _;
-                    (*info).dwarf_section = 0;
-                    (*info).dwarf_section_length = 0;
-                    (*info).dso_base = u.dso_base as u64;
+                    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;
 
                     return 1;
                 }
             }
+        } else {
+            reset_unwind_sections(info);
+            return 0;
         }
     }
 
-    (*info).compact_unwind_section = 0;
-    (*info).compact_unwind_section_length = 0;
-    (*info).dwarf_section = 0;
-    (*info).dwarf_section_length = 0;
-    (*info).dso_base = 0;
-
+    reset_unwind_sections(info);
     0
 }
 
@@ -187,10 +190,12 @@ impl CompactUnwindManager {
         }
         let mut offset = 0;
         while offset < len {
-            let entry = CompactUnwindEntry::from_ptr_and_len(
-                compact_unwind_section_ptr.wrapping_add(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>();
         }
@@ -250,6 +255,11 @@ impl CompactUnwindManager {
         let dso_base = self.dso_base;
 
         unsafe {
+            // TODO: refactor to not use static mut
+            #[allow(
+                static_mut_refs,
+                reason = "existing behaviour that was disallowed by edition 2024"
+            )]
             let mut uw_info = UNWIND_INFO.lock().map_err(|_| {
                 CompileError::Codegen("Failed to acquire lock for UnwindInfo!".into())
             })?;
@@ -330,7 +340,9 @@ impl CompactUnwindManager {
     }
 
     unsafe fn write_unwind_info(&mut self) -> CUResult<()> {
-        self.write_header()?;
+        unsafe {
+            self.write_header()?;
+        }
         self.write_personalities()?;
         self.write_indices()?;
         self.write_lsdas()?;
diff --git a/lib/compiler/src/engine/unwind/windows_x64.rs b/lib/compiler/src/engine/unwind/windows_x64.rs
index 7d7acf356e..d3281228ae 100644
--- a/lib/compiler/src/engine/unwind/windows_x64.rs
+++ b/lib/compiler/src/engine/unwind/windows_x64.rs
@@ -5,7 +5,7 @@
 use crate::types::unwind::CompiledFunctionUnwindInfoReference;
 use std::collections::HashMap;
 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);
 
@@ -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 e949a4329a..5a069efc71 100644
--- a/lib/compiler/src/lib.rs
+++ b/lib/compiler/src/lib.rs
@@ -18,7 +18,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!(
@@ -49,6 +49,7 @@ mod lib {
 mod engine;
 mod traits;
 
+pub mod misc;
 pub mod object;
 pub mod serialize;
 pub mod types;
@@ -70,10 +71,10 @@ pub use crate::compiler::{Compiler, CompilerConfig};
 mod translator;
 #[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/compiler/src/object/mod.rs b/lib/compiler/src/object/mod.rs
index dccbf84521..69b92928f1 100644
--- a/lib/compiler/src/object/mod.rs
+++ b/lib/compiler/src/object/mod.rs
@@ -15,13 +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 self::error::ObjectError;
 pub use self::module::{
-    emit_compilation, emit_data, emit_serialized, get_object_for_target, ObjectMetadataBuilder,
+    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
index 692a890723..1d6caf976b 100644
--- a/lib/compiler/src/object/module.rs
+++ b/lib/compiler/src/object/module.rs
@@ -9,17 +9,16 @@ use crate::{
     },
 };
 use object::{
-    elf, macho,
+    FileFlags, RelocationEncoding, RelocationFlags, RelocationKind, SectionKind, SymbolFlags,
+    SymbolKind, SymbolScope, elf, macho,
     write::{
         Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolId,
         SymbolSection,
     },
-    FileFlags, RelocationEncoding, RelocationKind, SectionKind, SymbolFlags, SymbolKind,
-    SymbolScope,
 };
+use wasmer_types::LocalFunctionIndex;
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::target::{Architecture, BinaryFormat, Endianness, PointerWidth, Triple};
-use wasmer_types::LocalFunctionIndex;
 
 const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
 
@@ -37,7 +36,7 @@ const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
 /// # Ok(())
 /// # }
 /// ```
-pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
+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,
@@ -162,7 +161,7 @@ pub fn emit_compilation(
         target_lexicon::Architecture::Aarch64(_) => {
             if matches!(
                 triple.operating_system,
-                target_lexicon::OperatingSystem::Darwin
+                target_lexicon::OperatingSystem::Darwin(_)
             ) {
                 8
             } else {
@@ -315,133 +314,113 @@ pub fn emit_compilation(
         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,
-                ),
-                Reloc::MachoArm64RelocBranch26 => (
-                    RelocationKind::MachO {
-                        value: macho::ARM64_RELOC_BRANCH26,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocUnsigned => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_UNSIGNED,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocSubtractor => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_SUBTRACTOR,
-                        relative: false,
+            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::X86PCRel4 => 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,
                     },
-                    RelocationEncoding::Generic,
-                    64,
-                ),
-                Reloc::MachoArm64RelocPage21 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_PAGE21,
-                        relative: true,
+                    object::BinaryFormat::MachO => RelocationFlags::MachO {
+                        r_type: macho::ARM64_RELOC_BRANCH26,
+                        r_pcrel: true,
+                        r_length: 32,
                     },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-
-                Reloc::MachoArm64RelocPageoff12 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_PAGEOFF12,
-                        relative: false,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocGotLoadPage21 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocGotLoadPageoff12 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocPointerToGot => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_POINTER_TO_GOT,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocTlvpLoadPage21 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocTlvpLoadPageoff12 => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-                Reloc::MachoArm64RelocAddend => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_ADDEND,
-                        relative: false,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                ),
-
+                    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,
+                },
                 other => {
                     return Err(ObjectError::UnsupportedArchitecture(format!(
                         "{} (relocation: {})",
                         triple.architecture, other
-                    )))
+                    )));
                 }
             };
 
@@ -452,15 +431,14 @@ pub fn emit_compilation(
                         section_id,
                         Relocation {
                             offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
+                            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) {
@@ -486,9 +464,7 @@ pub fn emit_compilation(
                         section_id,
                         Relocation {
                             offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
+                            flags: relocation_flags,
                             symbol: target_symbol,
                             addend: r.addend,
                         },
@@ -501,9 +477,7 @@ pub fn emit_compilation(
                         section_id,
                         Relocation {
                             offset: relocation_address,
-                            size: relocation_size,
-                            kind: relocation_kind,
-                            encoding: relocation_encoding,
+                            flags: relocation_flags,
                             symbol: *target_symbol,
                             addend: r.addend,
                         },
@@ -694,9 +668,11 @@ impl ObjectMetadataBuilder {
             Relocation {
                 offset: self.function_pointers_start_offset()
                     + self.pointer_bytes() * (index as u64),
-                size: self.pointer_width.bits(),
-                kind: RelocationKind::Absolute,
-                encoding: RelocationEncoding::Generic,
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
                 symbol: symbol_id,
                 addend: 0,
             },
@@ -716,9 +692,11 @@ impl ObjectMetadataBuilder {
             section_id,
             Relocation {
                 offset: self.trampolines_start_offset() + self.pointer_bytes() * (index as u64),
-                size: self.pointer_width.bits(),
-                kind: RelocationKind::Absolute,
-                encoding: RelocationEncoding::Generic,
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
                 symbol: symbol_id,
                 addend: 0,
             },
@@ -739,9 +717,11 @@ impl ObjectMetadataBuilder {
             Relocation {
                 offset: self.dynamic_function_trampoline_pointers_start_offset()
                     + self.pointer_bytes() * (index as u64),
-                size: self.pointer_width.bits(),
-                kind: RelocationKind::Absolute,
-                encoding: RelocationEncoding::Generic,
+                flags: RelocationFlags::Generic {
+                    kind: RelocationKind::Absolute,
+                    encoding: RelocationEncoding::Generic,
+                    size: self.pointer_width.bits(),
+                },
                 symbol: symbol_id,
                 addend: 0,
             },
diff --git a/lib/compiler/src/serialize.rs b/lib/compiler/src/serialize.rs
index 1071d700c4..3fd606b688 100644
--- a/lib/compiler/src/serialize.rs
+++ b/lib/compiler/src/serialize.rs
@@ -5,7 +5,7 @@
 #![allow(missing_docs)]
 
 use crate::types::{
-    function::{CompiledFunctionFrameInfo, FunctionBody, UnwindInfo, GOT},
+    function::{CompiledFunctionFrameInfo, FunctionBody, GOT, UnwindInfo},
     module::CompileModuleInfo,
     relocation::Relocation,
     section::{CustomSection, SectionIndex},
@@ -13,9 +13,9 @@ use crate::types::{
 use enumset::EnumSet;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 use wasmer_types::{
-    entity::PrimaryMap, target::CpuFeature, DeserializeError, Features, FunctionIndex,
-    LocalFunctionIndex, MemoryIndex, MemoryStyle, ModuleInfo, OwnedDataInitializer, SerializeError,
-    SignatureIndex, TableIndex, TableStyle,
+    DeserializeError, Features, FunctionIndex, LocalFunctionIndex, MemoryIndex, MemoryStyle,
+    ModuleInfo, OwnedDataInitializer, SerializeError, SignatureIndex, TableIndex, TableStyle,
+    entity::PrimaryMap, target::CpuFeature,
 };
 
 pub use wasmer_types::MetadataHeader;
@@ -91,8 +91,10 @@ impl SerializableModule {
     /// `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.
@@ -116,7 +118,7 @@ impl SerializableModule {
     pub unsafe fn archive_from_slice(
         metadata_slice: &[u8],
     ) -> Result<&ArchivedSerializableModule, DeserializeError> {
-        Ok(rkyv::access_unchecked(metadata_slice))
+        unsafe { Ok(rkyv::access_unchecked(metadata_slice)) }
     }
 
     /// Deserialize an archived module.
diff --git a/lib/compiler/src/traits.rs b/lib/compiler/src/traits.rs
index 60fd56eade..62581f5c69 100644
--- a/lib/compiler/src/traits.rs
+++ b/lib/compiler/src/traits.rs
@@ -4,11 +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::{
-    target::CpuFeature, DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex,
-    TableStyle,
+    DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+    target::CpuFeature,
 };
 
 /// An `Artifact` is the product that the `Engine`
diff --git a/lib/compiler/src/translator/environ.rs b/lib/compiler/src/translator/environ.rs
index 5e7b823cb6..fca7946451 100644
--- a/lib/compiler/src/translator/environ.rs
+++ b/lib/compiler/src/translator/environ.rs
@@ -7,8 +7,8 @@ use crate::translate_module;
 use crate::wasmparser::{Operator, ValType};
 use std::convert::{TryFrom, TryInto};
 use std::ops::Range;
-use wasmer_types::entity::PrimaryMap;
 use wasmer_types::FunctionType;
+use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     CustomSectionIndex, DataIndex, DataInitializer, DataInitializerLocation, ElemIndex,
     ExportIndex, FunctionIndex, GlobalIndex, GlobalInit, GlobalType, ImportIndex,
diff --git a/lib/compiler/src/translator/module.rs b/lib/compiler/src/translator/module.rs
index f460c2689d..0e7be73cbd 100644
--- a/lib/compiler/src/translator/module.rs
+++ b/lib/compiler/src/translator/module.rs
@@ -104,7 +104,7 @@ pub fn translate_module<'data>(
             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 291e325b4c..6c4d290f5c 100644
--- a/lib/compiler/src/translator/sections.rs
+++ b/lib/compiler/src/translator/sections.rs
@@ -14,11 +14,10 @@
 use super::environ::ModuleEnvironment;
 use super::error::from_binaryreadererror_wasmerror;
 use super::state::ModuleTranslationState;
-use crate::wasm_unsupported;
 use std::boxed::Box;
 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, TagIndex, Type, V128,
@@ -483,7 +482,7 @@ pub fn parse_data_section<'data>(
                         return Err(wasm_unsupported!(
                             "unsupported init expr in data section: {:?}",
                             s
-                        ))
+                        ));
                     }
                 };
                 environ.declare_data_initialization(
diff --git a/lib/compiler/src/types/function.rs b/lib/compiler/src/types/function.rs
index c0abc08e77..4c20c89d3f 100644
--- a/lib/compiler/src/types/function.rs
+++ b/lib/compiler/src/types/function.rs
@@ -19,12 +19,12 @@ use super::{
     },
 };
 use rkyv::{
-    option::ArchivedOption, Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
+    Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize, option::ArchivedOption,
 };
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use wasmer_types::{
-    entity::PrimaryMap, FunctionIndex, LocalFunctionIndex, SignatureIndex, TrapInformation,
+    FunctionIndex, LocalFunctionIndex, SignatureIndex, TrapInformation, entity::PrimaryMap,
 };
 
 /// The frame info for a Compiled function.
diff --git a/lib/compiler/src/types/module.rs b/lib/compiler/src/types/module.rs
index 5b0a851a14..5c1d9a14da 100644
--- a/lib/compiler/src/types/module.rs
+++ b/lib/compiler/src/types/module.rs
@@ -10,7 +10,7 @@ use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use wasmer_types::{
-    entity::PrimaryMap, Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+    Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle, entity::PrimaryMap,
 };
 
 /// The required info for compiling a module.
diff --git a/lib/compiler/src/types/relocation.rs b/lib/compiler/src/types/relocation.rs
index 58272f7c14..45df196b32 100644
--- a/lib/compiler/src/types/relocation.rs
+++ b/lib/compiler/src/types/relocation.rs
@@ -20,7 +20,7 @@ use crate::{Addend, CodeOffset};
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
-use wasmer_types::{entity::PrimaryMap, lib::std::fmt, LibCall, LocalFunctionIndex};
+use wasmer_types::{FunctionIndex, LibCall, LocalFunctionIndex, entity::PrimaryMap, lib::std::fmt};
 
 /// Relocation kinds for every ISA.
 #[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
@@ -449,6 +449,8 @@ impl RelocationLike for ArchivedRelocation {
 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
diff --git a/lib/compiler/src/types/symbols.rs b/lib/compiler/src/types/symbols.rs
index 00a4366d4c..609de200ff 100644
--- a/lib/compiler/src/types/symbols.rs
+++ b/lib/compiler/src/types/symbols.rs
@@ -9,9 +9,9 @@ use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use wasmer_types::{
-    entity::{EntityRef, PrimaryMap},
     DeserializeError, FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SerializeError,
     SignatureIndex,
+    entity::{EntityRef, PrimaryMap},
 };
 
 use super::{module::CompileModuleInfo, section::SectionIndex};
@@ -64,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,
 }
 
@@ -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,7 +132,7 @@ impl ModuleMetadata {
     unsafe fn archive_from_slice(
         metadata_slice: &[u8],
     ) -> Result<&ArchivedModuleMetadata, DeserializeError> {
-        Ok(rkyv::access_unchecked(metadata_slice))
+        unsafe { Ok(rkyv::access_unchecked(metadata_slice)) }
     }
 
     /// # Safety
diff --git a/lib/config/Cargo.toml b/lib/config/Cargo.toml
index 445a0aed6f..dbadfeb124 100644
--- a/lib/config/Cargo.toml
+++ b/lib/config/Cargo.toml
@@ -21,13 +21,13 @@ toml.workspace = true
 thiserror.workspace = true
 semver = { workspace = true, features = ["serde"] }
 indexmap = { workspace = true, features = ["serde"] }
-derive_builder = "0.12.0"
+derive_builder.workspace = true
 bytesize = { workspace = true, features = ["serde"] }
-schemars = { version = "0.8.16", features = ["url", "indexmap2"] }
+schemars = { workspace = true, features = ["url2", "indexmap2"] }
 url = { workspace = true, features = ["serde"] }
 hex.workspace = true
 ciborium.workspace = true
-saffron = { version = "0.1.0", features = ["std"] }
+saffron = { workspace = true, features = ["std"] }
 
 [dev-dependencies]
 pretty_assertions.workspace = true
diff --git a/lib/config/src/app/job.rs b/lib/config/src/app/job.rs
index ea478d7b77..790bae4381 100644
--- a/lib/config/src/app/job.rs
+++ b/lib/config/src/app/job.rs
@@ -1,13 +1,13 @@
 use std::{borrow::Cow, fmt::Display, str::FromStr};
 
 use anyhow::anyhow;
-use serde::{de::Error, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::Error};
 
 use indexmap::IndexMap;
 
 use crate::package::PackageSource;
 
-use super::{pretty_duration::PrettyDuration, AppConfigCapabilityMemoryV1, AppVolume, HttpRequest};
+use super::{AppConfigCapabilityMemoryV1, AppVolume, HttpRequest, pretty_duration::PrettyDuration};
 
 /// Job configuration.
 #[derive(
@@ -182,15 +182,20 @@ impl FromStr for JobTrigger {
             Ok(Self::PreDeployment)
         } else if s == "post-deployment" {
             Ok(Self::PostDeployment)
-        } else if let Ok(expr) = s.parse::<CronExpression>() {
-            Ok(Self::Cron(expr))
-        } else if let Ok(duration) = s.parse::<PrettyDuration>() {
-            Ok(Self::Duration(duration))
         } else {
-            Err(anyhow!(
-                "Invalid job trigger '{s}'. Must be 'pre-deployment', 'post-deployment', \
+            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'.",
-            ))
+                        ))
+                    }
+                }
+            }
         }
     }
 }
@@ -237,12 +242,16 @@ impl FromStr for CronExpression {
 }
 
 impl schemars::JsonSchema for JobTrigger {
-    fn schema_name() -> String {
-        "JobTrigger".to_owned()
+    fn schema_id() -> Cow<'static, str> {
+        Cow::Borrowed("JobTrigger")
+    }
+
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        String::json_schema(generator)
     }
 
-    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-        String::json_schema(gen)
+    fn schema_name() -> Cow<'static, str> {
+        Self::schema_id()
     }
 }
 
@@ -343,7 +352,7 @@ mod tests {
                     env: Some([("VAR1".to_owned(), "Value".to_owned())].into()),
                     capabilities: Some(super::ExecutableJobCompatibilityMapV1 {
                         memory: Some(crate::app::AppConfigCapabilityMemoryV1 {
-                            limit: Some(bytesize::ByteSize::gb(1)),
+                            limit: Some(bytesize::ByteSize::gib(1)),
                         }),
                         other: Default::default(),
                     }),
@@ -372,7 +381,7 @@ action:
       VAR1: Value
     capabilities:
       memory:
-        limit: 1000.0 MB
+        limit: 1.0 GiB
     volumes:
     - name: vol
       mount: /path/to/volume"#;
diff --git a/lib/config/src/app/mod.rs b/lib/config/src/app/mod.rs
index 714cbf95b6..4a07ad628e 100644
--- a/lib/config/src/app/mod.rs
+++ b/lib/config/src/app/mod.rs
@@ -9,7 +9,7 @@ mod ssh;
 
 pub use self::{healthcheck::*, http::*, job::*, pretty_duration::*, snapshot_trigger::*, ssh::*};
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use bytesize::ByteSize;
 use indexmap::IndexMap;
 
@@ -25,8 +25,8 @@ 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,
 )]
@@ -177,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
                 );
             }
@@ -189,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,
 )]
@@ -220,9 +219,8 @@ pub struct AppConfigCapabilityMapV1 {
 
 /// 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,
 )]
@@ -300,8 +298,8 @@ pub struct AppConfigCapabilityInstaBootV1 {
 #[serde(rename_all = "snake_case")]
 pub enum InstabootSnapshotModeV1 {
     /// Start the instance without any snapshot triggers. Once the requests are done,
-    /// use [`snapshot_and_stop`](wasmer_wasix::WasiProcess::snapshot_and_stop) to
-    /// capture a snapshot and shut the instance down.
+    /// use `wasmer_wasix::WasiProcess::snapshot_and_stop` to capture a snapshot
+    /// and shut the instance down.
     #[default]
     Bootstrap,
 
diff --git a/lib/config/src/app/pretty_duration.rs b/lib/config/src/app/pretty_duration.rs
index fcbeaf6bed..6133a561d7 100644
--- a/lib/config/src/app/pretty_duration.rs
+++ b/lib/config/src/app/pretty_duration.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use schemars::JsonSchema;
-use serde::{de::Error, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::Error};
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct PrettyDuration {
@@ -55,12 +55,20 @@ impl Ord for PrettyDuration {
 }
 
 impl JsonSchema for PrettyDuration {
-    fn schema_name() -> String {
-        "PrettyDuration".to_owned()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("PrettyDuration")
     }
 
-    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() -> Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
diff --git a/lib/config/src/app/snapshot_trigger.rs b/lib/config/src/app/snapshot_trigger.rs
index 9759ffa0b7..635c11e597 100644
--- a/lib/config/src/app/snapshot_trigger.rs
+++ b/lib/config/src/app/snapshot_trigger.rs
@@ -1,7 +1,7 @@
-use std::{fmt::Display, str::FromStr};
+use std::{borrow::Cow, fmt::Display, str::FromStr};
 
 use schemars::JsonSchema;
-use serde::{de::Error, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::Error};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum SnapshotTrigger {
@@ -107,11 +107,19 @@ impl<'de> Deserialize<'de> for SnapshotTrigger {
 }
 
 impl JsonSchema for SnapshotTrigger {
-    fn schema_name() -> String {
-        "SnapshotTrigger".to_owned()
+    fn schema_name() -> Cow<'static, str> {
+        Cow::Borrowed("SnapshotTrigger")
     }
 
-    fn json_schema(generator: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+    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/bin/generate-core-schemas.rs b/lib/config/src/bin/generate-core-schemas.rs
index 0fe8e4aad3..5e6443d8e4 100644
--- a/lib/config/src/bin/generate-core-schemas.rs
+++ b/lib/config/src/bin/generate-core-schemas.rs
@@ -43,11 +43,11 @@ mod codegen {
         let mut map = IndexMap::new();
 
         fn add_schema<T: schemars::JsonSchema>(map: &mut IndexMap<String, String>, name: &str) {
-            let gen =
-                schemars::gen::SchemaGenerator::new(schemars::gen::SchemaSettings::draft2019_09());
+            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");
@@ -65,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
     }
@@ -85,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() {
@@ -102,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/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 3345de0d76..cec1de476a 100644
--- a/lib/config/src/package/mod.rs
+++ b/lib/config/src/package/mod.rs
@@ -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
@@ -862,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(())
@@ -967,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` 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}\"")]
@@ -975,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,
@@ -996,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::*;
diff --git a/lib/config/src/package/named_package_ident.rs b/lib/config/src/package/named_package_ident.rs
index 9c43476047..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>,
@@ -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)
@@ -298,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(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() -> Cow<'static, str> {
+        Self::schema_name()
     }
 }
 
@@ -464,20 +474,28 @@ mod tests {
 
     #[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", "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")
+                .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@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()));
+        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 2bd6442183..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.
@@ -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 0e6a5544a7..6f8d744e5e 100644
--- a/lib/config/src/package/package_ident.rs
+++ b/lib/config/src/package/package_ident.rs
@@ -1,4 +1,4 @@
-use std::str::FromStr;
+use std::{borrow::Cow, str::FromStr};
 
 use super::{NamedPackageIdent, PackageHash, PackageId, PackageParseError};
 
@@ -55,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",
+                )),
+            }
         }
     }
 }
@@ -95,12 +96,20 @@ 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(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()
     }
 }
 
@@ -110,16 +119,22 @@ mod tests {
 
     #[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())));
+        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 57f873fa98..9633803c3f 100644
--- a/lib/derive/Cargo.toml
+++ b/lib/derive/Cargo.toml
@@ -13,13 +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-error2 = "2.0.1"
+syn = { workspace = true, features = ["full", "extra-traits", "derive", "parsing", "proc-macro"] }
+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"
+compiletest_rs.workspace = true
diff --git a/lib/derive/src/lib.rs b/lib/derive/src/lib.rs
index 6ec42cc237..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_error2::proc_macro_error;
-use syn::{parse_macro_input, DeriveInput};
+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 3d3c2c7693..be66a9cad3 100644
--- a/lib/derive/src/value_type.rs
+++ b/lib/derive/src/value_type.rs
@@ -1,31 +1,23 @@
-use proc_macro2::TokenStream;
 use proc_macro_error2::abort;
+use proc_macro2::TokenStream;
 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 771bdfe884..acdfe77fd2 100644
--- a/lib/derive/tests/compiletest.rs
+++ b/lib/derive/tests/compiletest.rs
@@ -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/journal/Cargo.toml b/lib/journal/Cargo.toml
index c475dfd914..00cdb4e0b0 100644
--- a/lib/journal/Cargo.toml
+++ b/lib/journal/Cargo.toml
@@ -33,12 +33,12 @@ thiserror.workspace = true
 bytes.workspace = true
 async-trait = { workspace = true }
 tracing.workspace = true
-bincode = { version = "1.3" }
+bincode.workspace = true
 serde = { workspace = true, default-features = false, features = ["derive"] }
 serde_json.workspace = true
 anyhow.workspace = true
 bytecheck.workspace = true
-lz4_flex = { version = "0.11" }
+lz4_flex.workspace = true
 num_enum.workspace = true
 
 [dev-dependencies]
diff --git a/lib/journal/src/concrete/aligned_cow_str.rs b/lib/journal/src/concrete/aligned_cow_str.rs
index b77e42c9f8..6c2143626b 100644
--- a/lib/journal/src/concrete/aligned_cow_str.rs
+++ b/lib/journal/src/concrete/aligned_cow_str.rs
@@ -1,10 +1,10 @@
 use std::{borrow::Cow, ops::Deref};
 
 use rkyv::{
+    Archive, Archived,
     rancor::Fallible,
     ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived,
 };
 
 #[derive(Clone)]
diff --git a/lib/journal/src/concrete/aligned_cow_vec.rs b/lib/journal/src/concrete/aligned_cow_vec.rs
index 08db36347e..f1a371ff96 100644
--- a/lib/journal/src/concrete/aligned_cow_vec.rs
+++ b/lib/journal/src/concrete/aligned_cow_vec.rs
@@ -5,10 +5,10 @@ use std::{
 };
 
 use rkyv::{
+    Archive, Archived,
     rancor::Fallible,
     ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived,
 };
 
 /// An aligned COW vector of bytes which avoids copying data
diff --git a/lib/journal/src/concrete/archived.rs b/lib/journal/src/concrete/archived.rs
index af403f705a..1a0e6331cb 100644
--- a/lib/journal/src/concrete/archived.rs
+++ b/lib/journal/src/concrete/archived.rs
@@ -2,7 +2,7 @@ use num_enum::{IntoPrimitive, TryFromPrimitive};
 use rkyv::rancor::Fallible;
 use rkyv::ser::{Allocator, Writer};
 use rkyv::{
-    api::serialize_using, Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
+    Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize, api::serialize_using,
 };
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::time::{Duration, SystemTime};
@@ -101,187 +101,215 @@ impl JournalEntryRecordType {
     pub unsafe fn deserialize_archive(self, data: &[u8]) -> anyhow::Result<JournalEntry<'_>> {
         match self {
             JournalEntryRecordType::InitModuleV1 => {
-                ArchivedJournalEntry::InitModuleV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::InitModuleV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::ClearEtherealV1 => {
-                ArchivedJournalEntry::ClearEtherealV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::ClearEtherealV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::ProcessExitV1 => {
-                ArchivedJournalEntry::ProcessExitV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::ProcessExitV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SetThreadV1 => {
-                ArchivedJournalEntry::SetThreadV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SetThreadV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CloseThreadV1 => {
-                ArchivedJournalEntry::CloseThreadV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CloseThreadV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::FileDescriptorSeekV1 => {
-                ArchivedJournalEntry::FileDescriptorSeekV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSeekV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::FileDescriptorWriteV1 => {
-                ArchivedJournalEntry::FileDescriptorWriteV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorWriteV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::UpdateMemoryRegionV1 => {
-                ArchivedJournalEntry::UpdateMemoryRegionV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::UpdateMemoryRegionV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SetClockTimeV1 => {
-                ArchivedJournalEntry::SetClockTimeV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SetClockTimeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::OpenFileDescriptorV1 => {
-                ArchivedJournalEntry::OpenFileDescriptorV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::OpenFileDescriptorV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::OpenFileDescriptorV2 => {
-                ArchivedJournalEntry::OpenFileDescriptorV2(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::OpenFileDescriptorV2(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CloseFileDescriptorV1 => {
-                ArchivedJournalEntry::CloseFileDescriptorV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CloseFileDescriptorV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::RenumberFileDescriptorV1 => {
-                ArchivedJournalEntry::RenumberFileDescriptorV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::RenumberFileDescriptorV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::DuplicateFileDescriptorV1 => {
-                ArchivedJournalEntry::DuplicateFileDescriptorV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::DuplicateFileDescriptorV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::DuplicateFileDescriptorV2 => {
-                ArchivedJournalEntry::DuplicateFileDescriptorV2(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::DuplicateFileDescriptorV2(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::CreateDirectoryV1 => {
-                ArchivedJournalEntry::CreateDirectoryV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CreateDirectoryV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::RemoveDirectoryV1 => {
-                ArchivedJournalEntry::RemoveDirectoryV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::RemoveDirectoryV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PathSetTimesV1 => {
-                ArchivedJournalEntry::PathSetTimesV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PathSetTimesV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::FileDescriptorSetTimesV1 => {
-                ArchivedJournalEntry::FileDescriptorSetTimesV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSetTimesV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetSizeV1 => {
-                ArchivedJournalEntry::FileDescriptorSetSizeV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSetSizeV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetFdFlagsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetFdFlagsV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSetFdFlagsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetFlagsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetFlagsV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSetFlagsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorSetRightsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetRightsV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorSetRightsV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorAdviseV1 => {
-                ArchivedJournalEntry::FileDescriptorAdviseV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorAdviseV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::FileDescriptorAllocateV1 => {
-                ArchivedJournalEntry::FileDescriptorAllocateV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::FileDescriptorAllocateV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::CreateHardLinkV1 => {
-                ArchivedJournalEntry::CreateHardLinkV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CreateHardLinkV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CreateSymbolicLinkV1 => {
-                ArchivedJournalEntry::CreateSymbolicLinkV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CreateSymbolicLinkV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::UnlinkFileV1 => {
-                ArchivedJournalEntry::UnlinkFileV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::UnlinkFileV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PathRenameV1 => {
-                ArchivedJournalEntry::PathRenameV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PathRenameV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::ChangeDirectoryV1 => {
-                ArchivedJournalEntry::ChangeDirectoryV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::ChangeDirectoryV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::EpollCreateV1 => {
-                ArchivedJournalEntry::EpollCreateV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::EpollCreateV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::EpollCtlV1 => {
-                ArchivedJournalEntry::EpollCtlV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::EpollCtlV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::TtySetV1 => {
-                ArchivedJournalEntry::TtySetV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::TtySetV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CreatePipeV1 => {
-                ArchivedJournalEntry::CreatePipeV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CreatePipeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::CreateEventV1 => {
-                ArchivedJournalEntry::CreateEventV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::CreateEventV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortAddAddrV1 => {
-                ArchivedJournalEntry::PortAddAddrV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PortAddAddrV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortDelAddrV1 => {
-                ArchivedJournalEntry::PortDelAddrV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PortDelAddrV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortAddrClearV1 => return Ok(JournalEntry::PortAddrClearV1),
             JournalEntryRecordType::PortBridgeV1 => {
-                ArchivedJournalEntry::PortBridgeV1(rkyv::access_unchecked(data))
+                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::access_unchecked(data))
+                ArchivedJournalEntry::PortGatewaySetV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortRouteAddV1 => {
-                ArchivedJournalEntry::PortRouteAddV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PortRouteAddV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::PortRouteClearV1 => return Ok(JournalEntry::PortRouteClearV1),
             JournalEntryRecordType::PortRouteDelV1 => {
-                ArchivedJournalEntry::PortRouteDelV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::PortRouteDelV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketOpenV1 => {
-                ArchivedJournalEntry::SocketOpenV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketOpenV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketPairV1 => {
-                ArchivedJournalEntry::SocketPairV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketPairV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketListenV1 => {
-                ArchivedJournalEntry::SocketListenV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketListenV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketBindV1 => {
-                ArchivedJournalEntry::SocketBindV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketBindV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketConnectedV1 => {
-                ArchivedJournalEntry::SocketConnectedV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketConnectedV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketAcceptedV1 => {
-                ArchivedJournalEntry::SocketAcceptedV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketAcceptedV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketJoinIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketJoinIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketLeaveIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketLeaveIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(unsafe {
+                    rkyv::access_unchecked(data)
+                })
             }
             JournalEntryRecordType::SocketSendFileV1 => {
-                ArchivedJournalEntry::SocketSendFileV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSendFileV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSendToV1 => {
-                ArchivedJournalEntry::SocketSendToV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSendToV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSendV1 => {
-                ArchivedJournalEntry::SocketSendV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSendV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSetOptFlagV1 => {
-                ArchivedJournalEntry::SocketSetOptFlagV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSetOptFlagV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSetOptSizeV1 => {
-                ArchivedJournalEntry::SocketSetOptSizeV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSetOptSizeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketSetOptTimeV1 => {
-                ArchivedJournalEntry::SocketSetOptTimeV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketSetOptTimeV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SocketShutdownV1 => {
-                ArchivedJournalEntry::SocketShutdownV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SocketShutdownV1(unsafe { rkyv::access_unchecked(data) })
             }
             JournalEntryRecordType::SnapshotV1 => {
-                ArchivedJournalEntry::SnapshotV1(rkyv::access_unchecked(data))
+                ArchivedJournalEntry::SnapshotV1(unsafe { rkyv::access_unchecked(data) })
             }
         }
         .try_into()
@@ -960,7 +988,7 @@ impl JournalEntry<'_> {
                 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)
     }
 }
diff --git a/lib/journal/src/concrete/archived_from.rs b/lib/journal/src/concrete/archived_from.rs
index 1d0690ae25..8d303423ea 100644
--- a/lib/journal/src/concrete/archived_from.rs
+++ b/lib/journal/src/concrete/archived_from.rs
@@ -708,11 +708,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 is_64bit: *is_64bit,
             },
             ArchivedJournalEntry::FileDescriptorSeekV1(
-                ArchivedJournalEntryFileDescriptorSeekV1 {
-                    fd,
-                    offset,
-                    ref whence,
-                },
+                ArchivedJournalEntryFileDescriptorSeekV1 { fd, offset, whence },
             ) => Self::FileDescriptorSeekV1 {
                 fd: fd.to_native(),
                 offset: offset.to_native(),
@@ -795,7 +791,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             },
             ArchivedJournalEntry::SnapshotV1(ArchivedJournalEntrySnapshotV1 {
                 since_epoch,
-                ref trigger,
+                trigger,
             }) => Self::SnapshotV1 {
                 when: SystemTime::UNIX_EPOCH
                     .checked_add((*since_epoch).into())
@@ -803,7 +799,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 trigger: trigger.into(),
             },
             ArchivedJournalEntry::SetClockTimeV1(ArchivedJournalEntrySetClockTimeV1 {
-                ref clock_id,
+                clock_id,
                 time,
             }) => Self::SetClockTimeV1 {
                 clock_id: clock_id.into(),
@@ -906,7 +902,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     fd,
                     offset,
                     len,
-                    ref advice,
+                    advice,
                 },
             ) => Self::FileDescriptorAdviseV1 {
                 fd: fd.to_native(),
@@ -955,9 +951,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             }
             ArchivedJournalEntry::EpollCtlV1(ArchivedJournalEntryEpollCtlV1 {
                 epfd,
-                ref op,
+                op,
                 fd,
-                ref event,
+                event,
             }) => Self::EpollCtlV1 {
                 epfd: epfd.to_native(),
                 op: op.into(),
@@ -1014,7 +1010,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()),
@@ -1045,8 +1041,8 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 Self::PortRouteDelV1 { ip: ip.as_ipaddr() }
             }
             ArchivedJournalEntry::SocketOpenV1(ArchivedJournalEntrySocketOpenV1 {
-                ref af,
-                ref ty,
+                af,
+                ty,
                 pt,
                 fd,
             }) => Self::SocketOpenV1 {
@@ -1179,7 +1175,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             },
             ArchivedJournalEntry::SocketSetOptFlagV1(ArchivedJournalEntrySocketSetOptFlagV1 {
                 fd,
-                ref opt,
+                opt,
                 flag,
             }) => Self::SocketSetOptFlagV1 {
                 fd: fd.to_native(),
@@ -1188,7 +1184,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             },
             ArchivedJournalEntry::SocketSetOptSizeV1(ArchivedJournalEntrySocketSetOptSizeV1 {
                 fd,
-                ref opt,
+                opt,
                 size,
             }) => Self::SocketSetOptSizeV1 {
                 fd: fd.to_native(),
@@ -1197,7 +1193,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             },
             ArchivedJournalEntry::SocketSetOptTimeV1(ArchivedJournalEntrySocketSetOptTimeV1 {
                 fd,
-                ref ty,
+                ty,
                 time,
             }) => Self::SocketSetOptTimeV1 {
                 fd: fd.to_native(),
@@ -1206,7 +1202,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             },
             ArchivedJournalEntry::SocketShutdownV1(ArchivedJournalEntrySocketShutdownV1 {
                 fd,
-                ref how,
+                how,
             }) => Self::SocketShutdownV1 {
                 fd: fd.to_native(),
                 how: how.into(),
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 17ed9e17b6..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 {
diff --git a/lib/journal/src/concrete/log_file.rs b/lib/journal/src/concrete/log_file.rs
index d2abd6e664..7ff96e54c7 100644
--- a/lib/journal/src/concrete/log_file.rs
+++ b/lib/journal/src/concrete/log_file.rs
@@ -3,10 +3,10 @@ use rkyv::{
     api::high::HighSerializer,
     rancor::Strategy,
     ser::{
+        Positional, Serializer, Writer,
         allocator::{Arena, ArenaHandle},
         sharing::Share,
         writer::IoWriter,
-        Positional, Serializer, Writer,
     },
 };
 use shared_buffer::OwnedBuffer;
@@ -120,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);
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 f39f36e757..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.
@@ -111,10 +107,14 @@ impl fmt::Display for JournalEntry<'_> {
             }
             JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => {
                 write!(f, "fd-seek (fd={fd}, offset={offset}, whence={whence:?})")
-            },
+            }
             JournalEntry::FileDescriptorWriteV1 {
                 fd, offset, data, ..
-            } => write!(f, "fd-write (fd={fd}, offset={offset}, data.len={})", data.len()),
+            } => write!(
+                f,
+                "fd-write (fd={fd}, offset={offset}, data.len={})",
+                data.len()
+            ),
             JournalEntry::SetClockTimeV1 { clock_id, time } => {
                 write!(f, "set-clock-time (id={clock_id:?}, time={time})")
             }
@@ -124,7 +124,7 @@ impl fmt::Display for JournalEntry<'_> {
             }
             | 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={fd}, path={path})")
@@ -145,12 +145,18 @@ impl fmt::Display for JournalEntry<'_> {
             JournalEntry::DuplicateFileDescriptorV1 {
                 original_fd,
                 copied_fd,
-            } => write!(f, "fd-duplicate (original={original_fd}, copied={copied_fd})"),
+            } => write!(
+                f,
+                "fd-duplicate (original={original_fd}, copied={copied_fd})"
+            ),
             JournalEntry::DuplicateFileDescriptorV2 {
                 original_fd,
                 copied_fd,
-                cloexec
-            } => write!(f, "fd-duplicate (original={original_fd}, copied={copied_fd}, cloexec={cloexec})"),
+                cloexec,
+            } => write!(
+                f,
+                "fd-duplicate (original={original_fd}, copied={copied_fd}, cloexec={cloexec})"
+            ),
             JournalEntry::CreateDirectoryV1 { fd, path } => {
                 write!(f, "path-create-dir (fd={fd}, path={path})")
             }
@@ -162,13 +168,19 @@ impl fmt::Display for JournalEntry<'_> {
                 st_atim,
                 st_mtim,
                 ..
-            } => write!(f, "path-set-times (path={path}, atime={st_atim}, mtime={st_mtim}))"),
+            } => write!(
+                f,
+                "path-set-times (path={path}, atime={st_atim}, mtime={st_mtim}))"
+            ),
             JournalEntry::FileDescriptorSetTimesV1 {
                 fd,
                 st_atim,
                 st_mtim,
                 ..
-            } => write!(f, "fd-set-times (fd={fd}, atime={st_atim}, mtime={st_mtim})"),
+            } => write!(
+                f,
+                "fd-set-times (fd={fd}, atime={st_atim}, mtime={st_mtim})"
+            ),
             JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags } => {
                 write!(f, "fd-set-fd-flags (fd={fd}, flags={flags:?})")
             }
@@ -179,7 +191,10 @@ impl fmt::Display for JournalEntry<'_> {
                 fd,
                 fs_rights_base,
                 fs_rights_inheriting,
-            } => write!(f, "fd-set-rights (fd={fd}, base={fs_rights_base:?}, inherited={fs_rights_inheriting:?})"),
+            } => write!(
+                f,
+                "fd-set-rights (fd={fd}, base={fs_rights_base:?}, inherited={fs_rights_inheriting:?})"
+            ),
             JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
                 write!(f, "fd-set-size (fd={fd}, size={st_size})")
             }
@@ -204,7 +219,11 @@ impl fmt::Display for JournalEntry<'_> {
             JournalEntry::EpollCtlV1 { 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::TtySetV1 { tty, line_feeds } => write!(
+                f,
+                "tty-set (echo={}, buffering={}, feeds={})",
+                tty.echo, tty.line_buffered, line_feeds
+            ),
             JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
                 write!(f, "fd-pipe (read_fd={read_fd}, write_fd={write_fd})")
             }
@@ -248,7 +267,10 @@ impl fmt::Display for JournalEntry<'_> {
                 local_addr,
                 peer_addr,
             } => {
-                write!(f, "sock-connect (fd={fd}, addr={local_addr}, peer={peer_addr})")
+                write!(
+                    f,
+                    "sock-connect (fd={fd}, addr={local_addr}, peer={peer_addr})"
+                )
             }
             JournalEntry::SocketAcceptedV1 {
                 listen_fd,
@@ -256,35 +278,59 @@ impl fmt::Display for JournalEntry<'_> {
                 local_addr,
                 peer_addr,
                 ..
-            } => write!(f, "sock-accept (listen-fd={listen_fd}, sock_fd={fd}, addr={local_addr}, peer={peer_addr})"),
+            } => write!(
+                f,
+                "sock-accept (listen-fd={listen_fd}, sock_fd={fd}, addr={local_addr}, peer={peer_addr})"
+            ),
             JournalEntry::SocketJoinIpv4MulticastV1 {
                 fd,
                 multiaddr,
                 iface,
-            } => write!(f, "sock-join-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"),
+            } => write!(
+                f,
+                "sock-join-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"
+            ),
             JournalEntry::SocketJoinIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(f, "sock-join-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"),
+            } => write!(
+                f,
+                "sock-join-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"
+            ),
             JournalEntry::SocketLeaveIpv4MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(f, "sock-leave-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"),
+            } => write!(
+                f,
+                "sock-leave-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"
+            ),
             JournalEntry::SocketLeaveIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(f, "sock-leave-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"),
+            } => write!(
+                f,
+                "sock-leave-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"
+            ),
             JournalEntry::SocketSendFileV1 {
                 socket_fd,
                 file_fd,
                 offset,
                 count,
-            } => write!(f, "sock-send-file (sock-fd={socket_fd}, file-fd={file_fd}, offset={offset}, count={count})"),
+            } => write!(
+                f,
+                "sock-send-file (sock-fd={socket_fd}, file-fd={file_fd}, offset={offset}, count={count})"
+            ),
             JournalEntry::SocketSendToV1 { fd, data, addr, .. } => {
-                write!(f, "sock-send-to (fd={}, data.len={}, addr={})", fd, data.len(), addr)
+                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())
diff --git a/lib/journal/src/concrete/tests.rs b/lib/journal/src/concrete/tests.rs
index a8c6c8c97a..d276c8ddec 100644
--- a/lib/journal/src/concrete/tests.rs
+++ b/lib/journal/src/concrete/tests.rs
@@ -9,9 +9,9 @@ use rkyv::{
     api::high::HighSerializer,
     rancor::Strategy,
     ser::{
+        Serializer,
         allocator::{Arena, ArenaHandle},
         sharing::Share,
-        Serializer,
     },
 };
 use wasmer_wasix_types::wasi;
diff --git a/lib/journal/src/entry.rs b/lib/journal/src/entry.rs
index 9cbd0056d2..356bf8d6ae 100644
--- a/lib/journal/src/entry.rs
+++ b/lib/journal/src/entry.rs
@@ -11,7 +11,7 @@ use wasmer_wasix_types::wasi::{
 };
 use wasmer_wasix_types::wasix::{ThreadStartType, WasiMemoryLayout};
 
-use crate::{base64, SnapshotTrigger};
+use crate::{SnapshotTrigger, base64};
 
 type Fd = u32;
 
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 d77b08bc87..7f277f73de 100644
--- a/lib/middlewares/src/metering.rs
+++ b/lib/middlewares/src/metering.rs
@@ -13,9 +13,9 @@ use std::fmt;
 use std::sync::{Arc, Mutex};
 use wasmer::wasmparser::{BlockType as WpTypeOrFuncType, Operator};
 use wasmer::{
-    sys::{FunctionMiddleware, MiddlewareError, MiddlewareReaderState, ModuleMiddleware},
     AsStoreMut, ExportIndex, GlobalInit, GlobalType, Instance, LocalFunctionIndex, Mutability,
     Type,
+    sys::{FunctionMiddleware, MiddlewareError, MiddlewareReaderState, ModuleMiddleware},
 };
 use wasmer_types::{GlobalIndex, ModuleInfo};
 
@@ -166,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.
@@ -303,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.
 ///
@@ -351,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.
 ///
@@ -400,9 +401,9 @@ mod tests {
     use std::sync::Arc;
     use wasmer::sys::EngineBuilder;
     use wasmer::{
-        imports,
+        Module, Store, TypedFunction, imports,
         sys::{CompilerConfig, Cranelift},
-        wat2wasm, Module, Store, TypedFunction,
+        wat2wasm,
     };
 
     fn cost_function(operator: &Operator) -> u64 {
diff --git a/lib/package/Cargo.toml b/lib/package/Cargo.toml
index 3fd4199944..46d12f646e 100644
--- a/lib/package/Cargo.toml
+++ b/lib/package/Cargo.toml
@@ -28,7 +28,7 @@ cfg-if.workspace = true
 ciborium.workspace = true
 semver.workspace = true
 url.workspace = true
-insta = { version = "1", features = ["filters", "yaml"] }
+insta = { workspace = true, features = ["filters", "yaml"] }
 flate2.workspace = true
 tar.workspace = true
 tempfile.workspace = true
@@ -40,6 +40,6 @@ libc.workspace = true
 [dev-dependencies]
 pretty_assertions.workspace = true
 tempfile.workspace = true
-regex = "1.11.0"
-ureq = "2.10.1"
-hexdump = "0.1.2"
+regex.workspace = true
+ureq.workspace = true
+hexdump.workspace = true
diff --git a/lib/package/src/convert/webc_to_package.rs b/lib/package/src/convert/webc_to_package.rs
index 81dea85b90..732707e4f2 100644
--- a/lib/package/src/convert/webc_to_package.rs
+++ b/lib/package/src/convert/webc_to_package.rs
@@ -7,7 +7,7 @@ use webc::Container;
 use super::ConversionError;
 
 /// Convert a webc image into a directory with a wasmer.toml file that can
-/// be used for generating a new pacakge.
+/// 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();
 
@@ -152,25 +152,22 @@ pub fn webc_to_package_dir(webc: &Container, target_dir: &Path) -> Result<(), Co
 
             let mut annotations = None;
 
-            if let Some(manifest_atom) = manifest.atoms.get(&atom_name) {
-                if let Some(sco) = manifest_atom
+            if let Some(manifest_atom) = manifest.atoms.get(&atom_name)
+                && let Some(sco) = manifest_atom
                     .annotations
                     .get(SuggestedCompilerOptimizations::KEY)
-                {
-                    if let Some((_, v)) = sco.as_map().and_then(|v| {
-                        v.iter().find(|(k, _)| {
-                            k.as_text().is_some_and(|v| {
-                                v == SuggestedCompilerOptimizations::PASS_PARAMS_KEY
-                            })
-                        })
-                    }) {
-                        annotations = Some(UserAnnotations {
-                            suggested_compiler_optimizations: SuggestedCompilerOptimizations {
-                                pass_params: Some(v.as_bool().unwrap_or_default()),
-                            },
-                        });
-                    }
-                }
+                && 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 {
@@ -253,7 +250,7 @@ mod tests {
 
     use super::*;
 
-    // Build a webc from a pacakge directory, and then restore the directory
+    // Build a webc from a package directory, and then restore the directory
     // from the webc.
     #[test]
     fn test_wasmer_package_webc_roundtrip() {
diff --git a/lib/package/src/macros.rs b/lib/package/src/macros.rs
index cfdb764c0c..49a0aa5fe7 100644
--- a/lib/package/src/macros.rs
+++ b/lib/package/src/macros.rs
@@ -7,7 +7,7 @@ use webc::Version;
 /// Construct a sequence of bytes using one or more items that implement the
 /// [`ToBytes`] trait.
 macro_rules! bytes {
-    ($($item:expr),* $(,)?) => {
+    ($($item:expr_2021),* $(,)?) => {
         {
             #[allow(unused_mut)]
             let mut buffer: ::bytes::BytesMut = ::bytes::BytesMut::new();
@@ -109,7 +109,7 @@ macro_rules! impl_to_bytes_le {
 impl_to_bytes_le!(u16, u32);
 
 macro_rules! assert_bytes_eq {
-    ($lhs:expr, $rhs:expr, $msg:literal $( $tokens:tt)*) => {{
+    ($lhs:expr_2021, $rhs:expr_2021, $msg:literal $( $tokens:tt)*) => {{
         let lhs = &$lhs[..];
         let rhs = &$rhs[..];
         if lhs != rhs {
@@ -123,7 +123,7 @@ macro_rules! assert_bytes_eq {
             pretty_assertions::assert_eq!(lhs.join("\n"), rhs.join("\n"), $msg $($tokens)*);
         }
     }};
-    ($lhs:expr, $rhs:expr) => {
+    ($lhs:expr_2021, $rhs:expr_2021) => {
         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
index e716e46332..bca3b2f82c 100644
--- a/lib/package/src/package/manifest.rs
+++ b/lib/package/src/package/manifest.rs
@@ -3,7 +3,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use ciborium::{cbor, Value};
+use ciborium::{Value, cbor};
 use semver::VersionReq;
 use sha2::Digest;
 use shared_buffer::{MmapError, OwnedBuffer};
@@ -20,19 +20,19 @@ use webc::{
 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,
     },
-    Atom, Binding, Command, Manifest as WebcManifest, UrlOrManifest, WaiBindings, WitBindings,
 };
 
 use super::{FsVolume, Strictness};
 
 const METADATA_VOLUME: &str = FsVolume::METADATA;
 
-/// Errors that may occur when converting from a [`wasmer_config::package::Manifest`] to
-/// a [`crate::metadata::Manifest`].
+/// 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 {
@@ -304,16 +304,15 @@ fn transform_atoms_shared(
     for (name, (kind, content, misc_annotations)) in atoms.iter() {
         // Create atom with annotations including Wasm features if available
         let mut annotations = IndexMap::new();
-        if let Some(misc_annotations) = misc_annotations {
-            if let Some(pass_params) = misc_annotations
+        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(),
-                );
-            }
+        {
+            annotations.insert(
+                SuggestedCompilerOptimizations::KEY.to_string(),
+                cbor!({"pass_params" => pass_params}).unwrap(),
+            );
         }
 
         // Detect required WebAssembly features by analyzing the module binary
@@ -833,10 +832,10 @@ impl RunnerKind {
 /// Infer the package's entrypoint.
 fn entrypoint(manifest: &WasmerManifest) -> Option<String> {
     // check if manifest.package is none
-    if let Some(package) = &manifest.package {
-        if let Some(entrypoint) = &package.entrypoint {
-            return Some(entrypoint.clone());
-        }
+    if let Some(package) = &manifest.package
+        && let Some(entrypoint) = &package.entrypoint
+    {
+        return Some(entrypoint.clone());
     }
 
     if let [only_command] = manifest.commands.as_slice() {
diff --git a/lib/package/src/package/mod.rs b/lib/package/src/package/mod.rs
index ac0a9c3644..d4df84327f 100644
--- a/lib/package/src/package/mod.rs
+++ b/lib/package/src/package/mod.rs
@@ -8,11 +8,11 @@ pub(crate) mod volume;
 pub use self::{
     manifest::ManifestError,
     package::{
-        include_everything_walker, wasmer_ignore_walker, Package, WalkBuilderFactory,
-        WasmerPackageError,
+        Package, WalkBuilderFactory, WasmerPackageError, include_everything_walker,
+        wasmer_ignore_walker,
     },
     strictness::Strictness,
-    volume::{fs::*, in_memory::*, WasmerPackageVolume},
+    volume::{WasmerPackageVolume, fs::*, in_memory::*},
 };
 
 #[cfg(test)]
diff --git a/lib/package/src/package/package.rs b/lib/package/src/package/package.rs
index 31fe6cab89..122dc012ad 100644
--- a/lib/package/src/package/package.rs
+++ b/lib/package/src/package/package.rs
@@ -1,3 +1,8 @@
+#![allow(
+    clippy::result_large_err,
+    reason = "WasmerPackageError is large, but not often used"
+)]
+
 use std::{
     borrow::Cow,
     collections::{BTreeMap, BTreeSet},
@@ -17,19 +22,19 @@ use tempfile::TempDir;
 use wasmer_config::package::Manifest as WasmerManifest;
 
 use webc::{
-    metadata::{annotations::Wapm, Manifest as WebcManifest},
+    AbstractVolume, AbstractWebc, Container, ContainerError, DetectError, PathSegment, Version,
+    Volume,
+    metadata::{Manifest as WebcManifest, annotations::Wapm},
     v3::{
-        write::{FileEntry, Writer},
         ChecksumAlgorithm, Timestamps,
+        write::{FileEntry, Writer},
     },
-    AbstractVolume, AbstractWebc, Container, ContainerError, DetectError, PathSegment, Version,
-    Volume,
 };
 
 use super::{
-    manifest::wasmer_manifest_to_webc,
-    volume::{fs::FsVolume, WasmerPackageVolume},
     ManifestError, MemoryVolume, Strictness,
+    manifest::wasmer_manifest_to_webc,
+    volume::{WasmerPackageVolume, fs::FsVolume},
 };
 
 /// Errors that may occur while loading a Wasmer package from disk.
@@ -339,12 +344,14 @@ impl Package {
         Package::load(wasmer_toml, base_dir, strictness, walker_factory)
     }
 
-    /// (Re)loads a package from a manifest.json file which was created as the result of calling [`Container::unpack`](crate::Container::unpack)
+    /// (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 which was created as the result of calling [`Container::unpack`](crate::Container::unpack)
+    /// (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,
@@ -693,12 +700,11 @@ fn tempdir() -> Result<TempDir, std::io::Error> {
         // directory is immutable, so let's try to use the current exe's
         // directory as our tempdir.
         // See also: https://github.com/wasmerio/wasmer/blob/482b78890b789f6867a91be9f306385e6255b260/lib/wasix/src/syscalls/wasi/path_create_directory.rs#L30-L32
-        if let Ok(current_exe) = std::env::current_exe() {
-            if let Some(parent) = current_exe.parent() {
-                if let Ok(temp) = TempDir::new_in(parent) {
-                    return Ok(temp);
-                }
-            }
+        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.
@@ -872,16 +878,16 @@ mod tests {
         time::SystemTime,
     };
 
-    use flate2::{write::GzEncoder, Compression};
+    use flate2::{Compression, write::GzEncoder};
     use sha2::Digest;
     use shared_buffer::OwnedBuffer;
     use tempfile::TempDir;
     use webc::{
+        PathSegment, PathSegments,
         metadata::{
-            annotations::{FileSystemMapping, VolumeSpecificPath},
             Binding, BindingsExtended, WaiBindings, WitBindings,
+            annotations::{FileSystemMapping, VolumeSpecificPath},
         },
-        PathSegment, PathSegments,
     };
 
     use crate::{package::*, utils::from_bytes};
diff --git a/lib/package/src/package/strictness.rs b/lib/package/src/package/strictness.rs
index 3831079e64..f5c14ac903 100644
--- a/lib/package/src/package/strictness.rs
+++ b/lib/package/src/package/strictness.rs
@@ -3,7 +3,7 @@ use std::{fmt::Debug, path::Path};
 use super::ManifestError;
 
 /// The strictness to use when working with a
-/// [`crate::wasmer_package::Package`].
+/// `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
diff --git a/lib/package/src/package/volume/fs.rs b/lib/package/src/package/volume/fs.rs
index f93094918b..6077a191a4 100644
--- a/lib/package/src/package/volume/fs.rs
+++ b/lib/package/src/package/volume/fs.rs
@@ -10,12 +10,11 @@ use anyhow::{Context, Error};
 use shared_buffer::OwnedBuffer;
 
 use webc::{
-    sanitize_path,
+    AbstractVolume, Metadata, PathSegment, PathSegments, Timestamps, ToPathSegments, sanitize_path,
     v3::{
         self,
         write::{DirEntry, Directory, FileEntry},
     },
-    AbstractVolume, Metadata, PathSegment, PathSegments, Timestamps, ToPathSegments,
 };
 
 use crate::package::{Strictness, WalkBuilderFactory};
@@ -25,8 +24,8 @@ use super::WasmerPackageVolume;
 /// A lazily loaded volume in a Wasmer package.
 ///
 /// Note that it is the package resolver's role to interpret a package's
-/// [`crate::metadata::annotations::FileSystemMappings`]. A [`Volume`] contains
-/// directories as they were when the package was published.
+/// filesystem mappings. A volume contains directories as they were when the
+/// package was published.
 pub struct FsVolume {
     /// Name of the volume
     name: String,
@@ -556,13 +555,11 @@ mod tests {
         let error = result.unwrap_err();
         assert!(
             error.to_string().contains("Unable to add"),
-            "Error message should indicate failure to add path: {}",
-            error
+            "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
+            "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
index 5754736661..5e47825c18 100644
--- a/lib/package/src/package/volume/in_memory.rs
+++ b/lib/package/src/package/volume/in_memory.rs
@@ -5,8 +5,8 @@ use std::{
 };
 
 use webc::{
-    v3::{self, write::FileEntry},
     AbstractVolume, Metadata, PathSegment, PathSegments,
+    v3::{self, write::FileEntry},
 };
 
 use crate::package::Strictness;
@@ -36,7 +36,7 @@ pub enum MemoryNode {
 }
 
 impl MemoryNode {
-    /// Try to return a [`MemoryDir`] out of [`self`].
+    /// Try to return a [`MemoryDir`] out of `self`.
     pub fn as_dir(&self) -> Option<&MemoryDir> {
         match self {
             MemoryNode::Dir(d) => Some(d),
@@ -44,7 +44,7 @@ impl MemoryNode {
         }
     }
 
-    /// Try to return a [`MemoryFile`] out of [`self`].
+    /// Try to return a [`MemoryFile`] out of `self`.
     pub fn as_file(&self) -> Option<&MemoryFile> {
         match self {
             MemoryNode::File(f) => Some(f),
@@ -226,8 +226,7 @@ impl WasmerPackageVolume for MemoryVolume {
         &self,
         strictness: Strictness,
     ) -> Result<webc::v3::write::Directory<'_>, anyhow::Error> {
-        let res = self.node.as_directory_tree(strictness);
-        res
+        self.node.as_directory_tree(strictness)
     }
 }
 
@@ -235,8 +234,8 @@ impl WasmerPackageVolume for MemoryVolume {
 mod tests {
     use sha2::{Digest, Sha256};
     use v3::{
-        write::Writer, Checksum, ChecksumAlgorithm, Index, IndexEntry, Signature,
-        SignatureAlgorithm, Span, Tag, Timestamps,
+        Checksum, ChecksumAlgorithm, Index, IndexEntry, Signature, SignatureAlgorithm, Span, Tag,
+        Timestamps, write::Writer,
     };
     use webc::metadata::Manifest;
 
diff --git a/lib/package/src/package/volume/mod.rs b/lib/package/src/package/volume/mod.rs
index cab6198608..28cff0e1cf 100644
--- a/lib/package/src/package/volume/mod.rs
+++ b/lib/package/src/package/volume/mod.rs
@@ -5,7 +5,7 @@ use std::{fmt::Debug, sync::Arc};
 
 use anyhow::Error;
 
-use webc::{v3::write::Directory, AbstractVolume};
+use webc::{AbstractVolume, v3::write::Directory};
 
 use super::Strictness;
 
diff --git a/lib/package/src/utils.rs b/lib/package/src/utils.rs
index 133933c189..073e5686e6 100644
--- a/lib/package/src/utils.rs
+++ b/lib/package/src/utils.rs
@@ -1,3 +1,8 @@
+#![allow(
+    clippy::result_large_err,
+    reason = "WasmerPackageError is large, but not often used"
+)]
+
 use bytes::{Buf, Bytes};
 use std::{
     fs::File,
diff --git a/lib/sdk/Cargo.toml b/lib/sdk/Cargo.toml
index 041f712712..a8ff6ec05f 100644
--- a/lib/sdk/Cargo.toml
+++ b/lib/sdk/Cargo.toml
@@ -27,12 +27,12 @@ sha2 = { workspace = true }
 semver = { workspace = true }
 toml = { workspace = true }
 bytesize = { workspace = true }
-walkdir = "2"
-zip = { version = "2.4", default-features = false, features = ["deflate"] }
+walkdir.workspace = true
+zip = { workspace = true, default-features = false, features = ["deflate"] }
 tracing = { workspace = true }
 ignore.workspace = true
 
 [dev-dependencies]
-rand = "0.9.1"
-tempfile = "3"
-url = "2"
+rand.workspace = true
+tempfile.workspace = true
+url.workspace = true
diff --git a/lib/sdk/src/app/deploy.rs b/lib/sdk/src/app/deploy.rs
index da021a91ec..a74ade961f 100644
--- a/lib/sdk/src/app/deploy.rs
+++ b/lib/sdk/src/app/deploy.rs
@@ -4,13 +4,13 @@ use anyhow::Context as _;
 use reqwest;
 use thiserror::Error;
 use wasmer_backend_api::{
-    types::{DeployApp, DeployAppVersion, PublishDeployAppVars},
     WasmerClient,
+    types::{DeployApp, DeployAppVersion, PublishDeployAppVars},
 };
 use wasmer_config::{app::AppConfigV1, package::PackageSource};
 
 use crate::package::publish::{
-    publish_package_directory, PackagePublishError, PublishOptions, PublishProgress, PublishWait,
+    PackagePublishError, PublishOptions, PublishProgress, PublishWait, publish_package_directory,
 };
 
 /// When waiting for an app deployment.
@@ -88,24 +88,24 @@ where
         .or_else(|| config.owner.clone())
         .ok_or(DeployError::MissingOwner)?;
 
-    if opts.publish_package {
-        if let PackageSource::Path(ref path) = config.package {
-            let publish_opts = PublishOptions {
-                namespace: Some(
-                    opts.package_namespace
-                        .clone()
-                        .unwrap_or_else(|| owner.clone()),
-                ),
-                timeout: opts.publish_timeout,
-                wait: PublishWait::Container,
-                ..Default::default()
-            };
-            let ident = publish_package_directory(client, path.as_ref(), publish_opts, |e| {
-                progress(DeployProgress::Publishing(e));
-            })
-            .await?;
-            config.package = ident.into();
-        }
+    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)?;
diff --git a/lib/sdk/src/app/deploy_remote_build.rs b/lib/sdk/src/app/deploy_remote_build.rs
index 7f5830e493..9ac479980b 100644
--- a/lib/sdk/src/app/deploy_remote_build.rs
+++ b/lib/sdk/src/app/deploy_remote_build.rs
@@ -7,15 +7,15 @@ use std::{
     time::Duration,
 };
 
-use anyhow::{bail, Context as _};
+use anyhow::{Context as _, bail};
 use futures_util::StreamExt;
 use reqwest::header::CONTENT_TYPE;
 use wasmer_backend_api::{
-    types::{AutoBuildDeployAppLogKind, AutobuildLog, DeployAppVersion, Id},
     WasmerClient,
+    types::{AutoBuildDeployAppLogKind, AutobuildLog, DeployAppVersion, Id},
 };
 use wasmer_config::app::AppConfigV1;
-use zip::{write::SimpleFileOptions, CompressionMethod};
+use zip::{CompressionMethod, write::SimpleFileOptions};
 
 use thiserror::Error;
 
@@ -251,27 +251,27 @@ where
         while let Some(event) = stream.next().await {
             tracing::debug!(?event, "received autobuild event");
             let event = event.map_err(|err| DeployRemoteError::Other(err.into()))?;
-            if let Some(data) = event.data {
-                if let Some(log) = data.autobuild_deployment {
-                    on_progress(DeployRemoteEvent::AutobuildLog { log: log.clone() });
-                    let message = log.message.clone();
-                    let kind = log.kind;
-
-                    match kind {
-                        AutoBuildDeployAppLogKind::Failed => {
-                            let msg = message.unwrap_or_else(|| "remote deployment failed".into());
-                            return Err(DeployRemoteError::DeploymentFailed(msg));
-                        }
-                        AutoBuildDeployAppLogKind::Complete => {
-                            let version = log
-                                .app_version
-                                .ok_or(DeployRemoteError::MissingAppVersion)?;
-
-                            final_version = Some(version);
-                            break 'OUTER;
-                        }
-                        _ => {}
+            if 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;
                     }
+                    _ => {}
                 }
             }
         }
diff --git a/lib/sdk/src/package/publish.rs b/lib/sdk/src/package/publish.rs
index 917c4684fa..8ed60aa77d 100644
--- a/lib/sdk/src/package/publish.rs
+++ b/lib/sdk/src/package/publish.rs
@@ -259,7 +259,7 @@ where
             name.as_deref(),
             &ns,
             &session_url,
-            Some(manifest.package.as_ref().map_or(true, |p| p.private)),
+            Some(manifest.package.as_ref().is_none_or(|p| p.private)),
         )
         .await
         .map_err(PackagePublishError::Api)?
@@ -323,7 +323,7 @@ where
         &id.full_name,
         Some(&ns),
         &package_release.id,
-        Some(manifest.package.as_ref().map_or(true, |p| p.private)),
+        Some(manifest.package.as_ref().is_none_or(|p| p.private)),
         readme_contents.as_deref(),
         manifest
             .package
diff --git a/lib/sdk/tests/publish_integration.rs b/lib/sdk/tests/publish_integration.rs
index fedde04385..d38897c5f8 100644
--- a/lib/sdk/tests/publish_integration.rs
+++ b/lib/sdk/tests/publish_integration.rs
@@ -8,7 +8,7 @@ use url::Url;
 
 use wasmer_backend_api::WasmerClient;
 
-use wasmer_sdk::package::publish::{publish_package_directory, PublishOptions, PublishWait};
+use wasmer_sdk::package::publish::{PublishOptions, PublishWait, publish_package_directory};
 
 /// Integration test for the package publishing logic.
 #[tokio::test]
diff --git a/lib/swift/Cargo.toml b/lib/swift/Cargo.toml
index a1ac910291..bb1a356316 100644
--- a/lib/swift/Cargo.toml
+++ b/lib/swift/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "wasmer-swift"
 version = "0.601.0"
-edition = "2021"
 description = "Experimental wasmer bindings for swift"
-license = "MIT"
+edition.workspace = true
+license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -13,8 +13,8 @@ name = "wasmer_swift"
 
 [dependencies]
 thiserror.workspace = true
-tokio = { version = "1.28.1", features = ["rt"], default-features = false }
-uniffi = "0.27"
+tokio = { workspace = true, features = ["rt"], default-features = false }
+uniffi.workspace = true
 virtual-fs = { path = "../virtual-fs", version = "=0.601.0", default-features = false, features = [
 	"webc-fs",
 ] }
@@ -30,7 +30,7 @@ wasmer-package.workspace = true
 
 
 [build-dependencies]
-uniffi = { version = "0.27", features = ["build"] }
+uniffi = { workspace = true, features = ["build"] }
 
 [package.metadata.docs.rs]
 features = ["wasmer/sys", "wasmer/compiler"]
diff --git a/lib/swift/src/lib.rs b/lib/swift/src/lib.rs
index ff01475e7b..b8a06d4b93 100644
--- a/lib/swift/src/lib.rs
+++ b/lib/swift/src/lib.rs
@@ -3,13 +3,10 @@ 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},
-        Runner,
-    },
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
     runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
-    PluggableRuntime,
 };
 
 uniffi::setup_scaffolding!();
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/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 39ad74aaab..5d7a6ea85b 100644
--- a/lib/types/Cargo.toml
+++ b/lib/types/Cargo.toml
@@ -23,7 +23,7 @@ enum-iterator.workspace = true
 target-lexicon = { workspace = true}
 enumset.workspace = true
 bytecheck.workspace = true
-xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
+xxhash-rust = { workspace = true, features = ["xxh64"] }
 sha2.workspace = true
 hex.workspace = true
 loupe = { workspace = true, optional = true }
diff --git a/lib/types/src/entity/boxed_slice.rs b/lib/types/src/entity/boxed_slice.rs
index 704457eb49..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};
@@ -51,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,
+            }
         }
     }
 
@@ -88,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/mod.rs b/lib/types/src/entity/mod.rs
index f4b527124c..21696530de 100644
--- a/lib/types/src/entity/mod.rs
+++ b/lib/types/src/entity/mod.rs
@@ -56,7 +56,7 @@ macro_rules! entity_impl {
 
     // Include basic `Display` impl using the given display prefix.
     // Display a `Block` reference as "block12".
-    ($entity:ident, $display_prefix:expr) => {
+    ($entity:ident, $display_prefix:expr_2021) => {
         entity_impl!($entity);
 
         impl $crate::lib::std::fmt::Display for $entity {
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 6a93f1509a..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;
@@ -109,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())
     }
 
@@ -283,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 4c96199664..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.
@@ -121,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())
     }
 
@@ -136,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()
     }
 
@@ -162,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 e72e9cf42e..f2be5c4429 100644
--- a/lib/types/src/error.rs
+++ b/lib/types/src/error.rs
@@ -142,9 +142,8 @@ 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 {
@@ -262,7 +261,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 {
diff --git a/lib/types/src/indexes.rs b/lib/types/src/indexes.rs
index f931b31f29..e0b6013d09 100644
--- a/lib/types/src/indexes.rs
+++ b/lib/types/src/indexes.rs
@@ -110,7 +110,7 @@ entity_impl!(LocalGlobalIndex);
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[rkyv(
-    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq, Hash),
     compare(PartialOrd, PartialEq)
 )]
 pub struct FunctionIndex(u32);
diff --git a/lib/types/src/lib.rs b/lib/types/src/lib.rs
index e9594a8851..8a313754ce 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!(
diff --git a/lib/types/src/libcalls.rs b/lib/types/src/libcalls.rs
index 11a2895ce9..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,16 +8,7 @@ use std::fmt;
 ///
 /// This list is likely to grow over time.
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    Hash,
-    IntoEnumIterator,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
+    Copy, Clone, Debug, PartialEq, Eq, Hash, Sequence, RkyvSerialize, RkyvDeserialize, Archive,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
@@ -133,23 +124,18 @@ 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,
 
-    /// rethrow
-    Rethrow,
-
-    /// alloc_exception
+    /// allocate exception object and get an exnref for it
     AllocException,
-
-    /// delete_exception
-    DeleteException,
-
-    /// read_exception
-    ReadException,
+    /// 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,
@@ -209,12 +195,11 @@ impl LibCall {
             Self::Memory32AtomicNotify => "wasmer_vm_memory32_atomic_notify",
             Self::ImportedMemory32AtomicNotify => "wasmer_vm_imported_memory32_atomic_notify",
             Self::Throw => "wasmer_vm_throw",
-            Self::Rethrow => "wasmer_vm_rethrow",
             Self::EHPersonality => "wasmer_eh_personality",
             Self::EHPersonality2 => "wasmer_eh_personality2",
             Self::AllocException => "wasmer_vm_alloc_exception",
-            Self::DeleteException => "wasmer_vm_delete_exception",
-            Self::ReadException => "wasmer_vm_read_exception",
+            Self::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/module.rs b/lib/types/src/module.rs
index 93c02a48a0..4601df86a0 100644
--- a/lib/types/src/module.rs
+++ b/lib/types/src/module.rs
@@ -575,6 +575,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 6d18a2497c..7d2538c841 100644
--- a/lib/types/src/module_hash.rs
+++ b/lib/types/src/module_hash.rs
@@ -42,8 +42,8 @@ pub enum ModuleHash {
 impl loupe::MemoryUsage for ModuleHash {
     fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
         match self {
-            ModuleHash::XXHash(_) => 8 * 8,
-            ModuleHash::Sha256(_) => 8 * 32,
+            Self::XXHash(_) => 8 * 8,
+            Self::Sha256(_) => 8 * 32,
         }
     }
 }
diff --git a/lib/types/src/serialize.rs b/lib/types/src/serialize.rs
index 178ad2fea5..6e80335805 100644
--- a/lib/types/src/serialize.rs
+++ b/lib/types/src/serialize.rs
@@ -1,4 +1,4 @@
-use crate::{lib::std::mem, DeserializeError};
+use crate::{DeserializeError, lib::std::mem};
 
 /// Metadata header which holds an ABI version and the length of the remaining
 /// metadata.
@@ -13,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 = 11;
+    pub const CURRENT_VERSION: u32 = 12;
 
     /// Magic number to identify wasmer metadata.
     const MAGIC: [u8; 8] = *b"WASMER\0\0";
@@ -40,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/target.rs b/lib/types/src/target.rs
index 53a2841728..c0e4eada1e 100644
--- a/lib/types/src/target.rs
+++ b/lib/types/src/target.rs
@@ -48,7 +48,7 @@ pub enum CpuFeature {
     LZCNT,
     // ARM features
     NEON,
-    // Risc-V features
+    // RISC-V features
 }
 
 impl CpuFeature {
@@ -126,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
diff --git a/lib/types/src/trapcode.rs b/lib/types/src/trapcode.rs
index 04efd035be..2e85a785a8 100644
--- a/lib/types/src/trapcode.rs
+++ b/lib/types/src/trapcode.rs
@@ -63,6 +63,13 @@ pub enum TrapCode {
 
     /// 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 {
@@ -81,6 +88,10 @@ impl TrapCode {
             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`"
+            }
         }
     }
 }
@@ -100,6 +111,8 @@ impl Display for TrapCode {
             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)
     }
@@ -121,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 91379d3fd8..b1b122aa07 100644
--- a/lib/types/src/types.rs
+++ b/lib/types/src/types.rs
@@ -360,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 }
     }
 }
 
@@ -452,7 +448,7 @@ pub enum GlobalInit {
 
 // Tag Types
 
-/// The kind of a [`Tag`].
+/// The kind of a tag.
 ///
 /// Currently, tags can only express exceptions.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
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 1ca5e235e9..6a5ccc6162 100644
--- a/lib/types/src/vmoffsets.rs
+++ b/lib/types/src/vmoffsets.rs
@@ -142,44 +142,19 @@ impl VMBuiltinFunctionIndex {
         Self(29)
     }
 
-    /// Returns an index for wasm's imported `throw` builtin function.
-    pub const fn get_imported_throw_index() -> Self {
-        Self(30)
-    }
-
-    /// Returns an index for wasm's imported `rethrow` builtin function.
-    pub const fn get_imported_rethrow_index() -> Self {
-        Self(31)
-    }
-
-    /// Returns an index for wasm's imported `alloc_exception` builtin function.
-    pub const fn get_imported_alloc_exception_index() -> Self {
-        Self(32)
-    }
-
-    /// Returns an index for wasm's imported `delete_exception` builtin function.
-    pub const fn get_imported_delete_exception_index() -> Self {
-        Self(33)
-    }
-
-    /// Returns an index for wasm's imported `read_exception` builtin function.
-    pub const fn get_imported_read_exception_index() -> Self {
-        Self(34)
-    }
-
     /// Returns an index for wasm's imported `debug_usize` builtin function.
     pub const fn get_imported_debug_usize_index() -> Self {
-        Self(35)
+        Self(30)
     }
 
     /// Returns an index for wasm's imported `debug_str` builtin function.
     pub const fn get_imported_debug_str_index() -> Self {
-        Self(36)
+        Self(31)
     }
 
     /// Returns the total number of builtin functions.
     pub const fn builtin_functions_total_number() -> u32 {
-        37
+        32
     }
 
     /// Return the index as an u32 number.
@@ -850,7 +825,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 aef86f9ca1..22dba3b87c 100644
--- a/lib/virtual-fs/Cargo.toml
+++ b/lib/virtual-fs/Cargo.toml
@@ -14,19 +14,19 @@ wasmer-package.workspace = true
 virtual-mio = { path = "../virtual-io", version = "0.601.0", default-features = false }
 dashmap.workspace = true
 derive_more.workspace = true
-dunce = "1.0.4"
+dunce.workspace = true
 anyhow = { workspace = true, optional = true }
 async-trait = { workspace = true }
 bytes.workspace = true
-filetime = { version = "0.2.18", optional = true }
-fs_extra = { version = "1.2.0", optional = true }
-futures = { version = "0.3" }
+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"
+pin-project-lite.workspace = true
+replace_with.workspace = true
 shared-buffer.workspace = true
-slab = { version = "0.4" }
+slab.workspace = true
 thiserror.workspace = true
 
 tokio = { workspace = true, features = [
@@ -34,14 +34,14 @@ tokio = { workspace = true, features = [
 	"sync",
 	"macros",
 ], default-features = false }
-tracing.workspace = true
-typetag = { version = "0.1", optional = true }
+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 = { version = "1.1", optional = true }
+web-time = { workspace = true, optional = true }
 
 [dev-dependencies]
 pretty_assertions.workspace = true
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/builder.rs b/lib/virtual-fs/src/builder.rs
index 0f74372236..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)) {
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 82bd50d137..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(),
         })
@@ -718,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")))
     }
 }
 
@@ -765,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")))
     }
 }
 
@@ -804,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")))
     }
 }
 
@@ -851,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")))
     }
 }
 
@@ -958,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(
@@ -983,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")))
     }
 }
 
diff --git a/lib/virtual-fs/src/lib.rs b/lib/virtual-fs/src/lib.rs
index 2f0017fa98..5a9d35f99c 100644
--- a/lib/virtual-fs/src/lib.rs
+++ b/lib/virtual-fs/src/lib.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(test)]
 #[macro_use]
@@ -83,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>;
@@ -98,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 {
@@ -153,7 +153,7 @@ where
         (**self).remove_file(path)
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         (**self).new_open_options()
     }
 
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 cc12fd2c9f..7276ee7bf0 100644
--- a/lib/virtual-fs/src/mem_fs/file.rs
+++ b/lib/virtual-fs/src/mem_fs/file.rs
@@ -385,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 {
@@ -440,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 {
@@ -488,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 {
@@ -522,12 +526,12 @@ impl VirtualFile for FileHandle {
 
 #[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;
 
     macro_rules! path {
-        ($path:expr) => {
+        ($path:expr_2021) => {
             std::path::Path::new($path)
         };
     }
@@ -715,9 +719,11 @@ 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 {
@@ -782,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),
-                            )))
+                            )));
                         }
                     }
                 }
@@ -807,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 {
@@ -876,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 {
@@ -930,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 {
@@ -983,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),
-                            )))
+                            )));
                         }
                     }
                 }
@@ -991,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),
-                    )))
+                    )));
                 }
             }
         };
@@ -1006,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 {
@@ -1068,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 {
@@ -1104,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 {
@@ -1170,11 +1185,11 @@ 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 {
-        ($path:expr) => {
+        ($path:expr_2021) => {
             std::path::Path::new($path)
         };
     }
diff --git a/lib/virtual-fs/src/mem_fs/file_opener.rs b/lib/virtual-fs/src/mem_fs/file_opener.rs
index 32d96120e3..ed8353c49d 100644
--- a/lib/virtual-fs/src/mem_fs/file_opener.rs
+++ b/lib/virtual-fs/src/mem_fs/file_opener.rs
@@ -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,11 +557,11 @@ 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 {
-        ($path:expr) => {
+        ($path:expr_2021) => {
             std::path::Path::new($path)
         };
     }
diff --git a/lib/virtual-fs/src/mem_fs/filesystem.rs b/lib/virtual-fs/src/mem_fs/filesystem.rs
index 7a336fb89d..5e32947b59 100644
--- a/lib/virtual-fs/src/mem_fs/filesystem.rs
+++ b/lib/virtual-fs/src/mem_fs/filesystem.rs
@@ -696,7 +696,7 @@ impl crate::FileSystem for FileSystem {
         Ok(())
     }
 
-    fn new_open_options(&self) -> OpenOptions {
+    fn new_open_options(&self) -> OpenOptions<'_> {
         OpenOptions::new(self)
     }
 
@@ -1156,14 +1156,14 @@ mod test_filesystem {
     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) => {
+        ($path:expr_2021) => {
             std::path::Path::new($path)
         };
 
-        (buf $path:expr) => {
+        (buf $path:expr_2021) => {
             std::path::PathBuf::from($path)
         };
     }
diff --git a/lib/virtual-fs/src/mem_fs/offloaded_file.rs b/lib/virtual-fs/src/mem_fs/offloaded_file.rs
index b89d243d93..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 {:?}",
@@ -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 a13f5d026d..0dddee388c 100644
--- a/lib/virtual-fs/src/mem_fs/stdio.rs
+++ b/lib/virtual-fs/src/mem_fs/stdio.rs
@@ -5,7 +5,7 @@ use crate::{FsError, Result, VirtualFile};
 use std::io::{self, Write};
 
 macro_rules! impl_virtualfile_on_std_streams {
-    ($name:ident { readable: $readable:expr, writable: $writable:expr $(,)* }) => {
+    ($name:ident { readable: $readable:expr_2021, writable: $writable:expr_2021 $(,)* }) => {
         /// A wrapper type around the standard I/O stream of the same
         /// name that implements `VirtualFile`.
         #[derive(Debug, Default)]
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 780b3fb860..0554cb407f 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);
 
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/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 5058dc1c42..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]
diff --git a/lib/virtual-fs/src/webc_volume_fs.rs b/lib/virtual-fs/src/webc_volume_fs.rs
index b14309e262..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::SharedBytes, Container, Metadata as WebcMetadata, PathSegmentError, PathSegments,
-    ToPathSegments, Volume,
+    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)
     }
 
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 cb795457dd..5d34268462 100644
--- a/lib/virtual-io/Cargo.toml
+++ b/lib/virtual-io/Cargo.toml
@@ -17,8 +17,9 @@ tracing.workspace = true
 
 mio = { workspace = true, features = ["os-poll"], optional = true }
 socket2 = { workspace = true, optional = true }
-futures = { version = "0.3" }
+futures = { workspace = true }
 serde = { workspace = true, default-features = false, features = ["derive"] }
+parking.workspace = true
 
 [dev-dependencies]
 mio = { workspace = true, features = ["os-poll", "os-ext"] }
diff --git a/lib/virtual-io/src/guard.rs b/lib/virtual-io/src/guard.rs
index 71a11c319f..60d5596014 100644
--- a/lib/virtual-io/src/guard.rs
+++ b/lib/virtual-io/src/guard.rs
@@ -43,11 +43,12 @@ 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),
         }
     }
 
diff --git a/lib/virtual-io/src/selector.rs b/lib/virtual-io/src/selector.rs
index eff0b463d6..b53e018eb3 100644
--- a/lib/virtual-io/src/selector.rs
+++ b/lib/virtual-io/src/selector.rs
@@ -3,8 +3,8 @@ use std::{
     collections::HashMap,
     io,
     sync::{
-        atomic::{AtomicBool, AtomicUsize, Ordering},
         Arc, Mutex,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
     },
 };
 
@@ -320,7 +320,7 @@ mod tests {
         fn push_interest(&mut self, _interest: InterestType) {
             // This would deadlock without a queue
             self.selector
-                .remove(self.token.lock().unwrap().unwrap().clone(), None)
+                .remove(self.token.lock().unwrap().unwrap(), None)
                 .unwrap();
             self.success_sender.send(()).unwrap();
         }
@@ -355,7 +355,7 @@ mod tests {
         thread::sleep(Duration::from_millis(10));
 
         // Works once
-        sender.write(&[1, 2, 3]).unwrap();
+        sender.write_all(&[1, 2, 3]).unwrap();
         sender.flush().unwrap();
         thread::sleep(Duration::from_millis(10));
         assert!(
@@ -369,7 +369,7 @@ mod tests {
         thread::sleep(Duration::from_millis(10));
 
         // Works multiple times
-        sender.write(&[1, 2, 3]).unwrap();
+        sender.write_all(&[1, 2, 3]).unwrap();
         sender.flush().unwrap();
         thread::sleep(Duration::from_millis(10));
         assert!(
@@ -384,7 +384,7 @@ mod tests {
 
         // No signal after removing the handler
         selector.remove(token, Some(&mut receiver)).unwrap();
-        sender.write(&[1, 2, 3]).unwrap();
+        sender.write_all(&[1, 2, 3]).unwrap();
         sender.flush().unwrap();
         thread::sleep(Duration::from_millis(10));
         assert!(
@@ -416,7 +416,7 @@ mod tests {
             .unwrap();
         handler_token_arcmutex.lock().unwrap().replace(token);
 
-        sender.write(&[1, 2, 3]).unwrap();
+        sender.write_all(&[1, 2, 3]).unwrap();
         sender.flush().unwrap();
 
         thread::sleep(Duration::from_millis(100));
diff --git a/lib/virtual-io/src/waker.rs b/lib/virtual-io/src/waker.rs
index ceed26bb15..a2c8e9afbd 100644
--- a/lib/virtual-io/src/waker.rs
+++ b/lib/virtual-io/src/waker.rs
@@ -1,77 +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) }
-    }
-
-    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 1ba32682e6..58590a135a 100644
--- a/lib/virtual-net/Cargo.toml
+++ b/lib/virtual-net/Cargo.toml
@@ -14,8 +14,8 @@ base64.workspace = true
 hyper = { workspace = true, optional = true }
 rkyv = { workspace = true, optional = true }
 
-ipnet = "2.10.1"
-iprange = "0.6.7"
+ipnet.workspace = true
+iprange.workspace = true
 thiserror.workspace = true
 bytes.workspace = true
 async-trait = { workspace = true }
@@ -26,20 +26,20 @@ mio = { workspace = true, optional = true }
 socket2 = { workspace = true, optional = true }
 derive_more.workspace = true
 virtual-mio = { path = "../virtual-io", version = "0.601.0", default-features = false }
-bincode = { version = "1.3" }
+bincode.workspace = true
 serde = { workspace = true, default-features = false, features = ["derive"] }
-pin-project-lite = "0.2.9"
+pin-project-lite.workspace = true
 futures-util.workspace = true
 anyhow.workspace = true
-tokio-serde = { version = "0.9", features = ["bincode"], optional = true }
-tokio-util = { version = "0.7.8", features = ["codec"], optional = true }
-hyper-tungstenite = { version = "0.13", optional = true }
+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"]
 
@@ -49,7 +49,7 @@ tokio = { workspace = true, default-features = false, features = [
 	"rt-multi-thread",
 ] }
 tracing-test.workspace = true
-serial_test = "2.0.0"
+serial_test.workspace = true
 
 [features]
 default = [
diff --git a/lib/virtual-net/src/client.rs b/lib/virtual-net/src/client.rs
index 7219fc574f..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,11 +17,11 @@ use std::time::Duration;
 
 use bytes::Buf;
 use bytes::BytesMut;
-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;
@@ -29,6 +29,7 @@ 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 => {}
@@ -1003,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 => {
@@ -1014,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 => {
@@ -1025,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 => {
@@ -1065,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,
@@ -1130,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 => {
@@ -1145,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 => {
@@ -1219,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 => {
@@ -1283,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 => {
@@ -1298,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 => {
@@ -1313,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 => {
@@ -1328,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 => {
@@ -1363,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)),
@@ -1383,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)),
@@ -1457,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 => {
@@ -1472,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 => {
@@ -1487,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 => {
@@ -1502,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 => {
@@ -1517,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 => {
@@ -1528,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 => {
@@ -1548,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/host.rs b/lib/virtual-net/src/host.rs
index 2e4a8ab591..ecb8a8f01f 100644
--- a/lib/virtual-net/src/host.rs
+++ b/lib/virtual-net/src/host.rs
@@ -1,12 +1,12 @@
 #![allow(unused_variables)]
 use crate::ruleset::{Direction, Ruleset};
-use crate::{io_err_into_net_error, VirtualIoSource};
 #[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 std::collections::VecDeque;
 use std::io::{self, Read, Write};
@@ -26,7 +26,7 @@ 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(Debug)]
@@ -76,11 +76,11 @@ impl VirtualNetworking for LocalNetworking {
         reuse_port: bool,
         reuse_addr: bool,
     ) -> Result<Box<dyn VirtualTcpListener + Sync>> {
-        if let Some(ruleset) = self.ruleset.as_ref() {
-            if !ruleset.allows_socket(addr, Direction::Inbound) {
-                tracing::warn!(%addr, "listen_tcp blocked by firewall rule");
-                return Err(NetworkError::PermissionDenied);
-            }
+        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)
@@ -106,13 +106,14 @@ impl VirtualNetworking for LocalNetworking {
         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() {
-            if !ruleset.allows_socket(addr, Direction::Inbound) {
-                tracing::warn!(%addr, "bind_udp blocked by firewall rule");
-                return Err(NetworkError::PermissionDenied);
-            }
+        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))]
@@ -167,11 +168,11 @@ impl VirtualNetworking for LocalNetworking {
         _addr: SocketAddr,
         mut peer: SocketAddr,
     ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
-        if let Some(ruleset) = self.ruleset.as_ref() {
-            if !ruleset.allows_socket(peer, Direction::Outbound) {
-                tracing::warn!(%peer, "connect_tcp blocked by firewall rule");
-                return Err(NetworkError::PermissionDenied);
-            }
+        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)?;
@@ -189,11 +190,11 @@ impl VirtualNetworking for LocalNetworking {
         port: Option<u16>,
         dns_server: Option<IpAddr>,
     ) -> Result<Vec<IpAddr>> {
-        if let Some(ruleset) = self.ruleset.as_ref() {
-            if !ruleset.allows_domain(host) {
-                tracing::warn!(%host, "dns resolve blocked by firewall rule");
-                return Err(NetworkError::PermissionDenied);
-            }
+        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(':') {
@@ -236,11 +237,11 @@ 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)) => {
-                if let Some(ruleset) = self.ruleset.as_ref() {
-                    if !ruleset.allows_socket(addr, Direction::Outbound) {
-                        tracing::warn!(%addr, "try_accept blocked by firewall rule");
-                        return Err(NetworkError::PermissionDenied);
-                    }
+                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);
@@ -853,11 +854,11 @@ impl VirtualUdpSocket for LocalUdpSocket {
 
 impl VirtualConnectionlessSocket for LocalUdpSocket {
     fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize> {
-        if let Some(ruleset) = self.ruleset.as_ref() {
-            if !ruleset.allows_socket(addr, Direction::Outbound) {
-                tracing::warn!(%addr, "try_send blocked by firewall rule");
-                return Err(NetworkError::PermissionDenied);
-            }
+        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
diff --git a/lib/virtual-net/src/lib.rs b/lib/virtual-net/src/lib.rs
index ba556ff35b..22ae000a49 100644
--- a/lib/virtual-net/src/lib.rs
+++ b/lib/virtual-net/src/lib.rs
@@ -1,4 +1,4 @@
-#![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;
@@ -47,9 +47,9 @@ 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>;
 
@@ -656,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/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
index aa9f884e58..0cc7e42ae0 100644
--- a/lib/virtual-net/src/ruleset.rs
+++ b/lib/virtual-net/src/ruleset.rs
@@ -398,10 +398,10 @@ impl Rule {
 
     /// Returns allowed ports for the specified `domain` if this rule is a DNS rule
     pub fn port_spec_of_domain(&mut self, domain: impl AsRef<str>) -> Option<PortSpec> {
-        if let Rule::DNS(rule) = self {
-            if rule.allows(domain) {
-                return Some(rule.allowed_ports());
-            }
+        if let Rule::DNS(rule) = self
+            && rule.allows(domain)
+        {
+            return Some(rule.allowed_ports());
         }
 
         None
@@ -676,7 +676,7 @@ impl Ruleset {
     pub fn allows_socket(&self, addr: impl Into<SocketAddr>, dir: Direction) -> bool {
         let addr = addr.into();
 
-        let is_allowed = {
+        {
             let ruleset = self.rules.read().unwrap();
 
             let is_blacklisted = ruleset.iter().any(|r| r.blocks_socket(addr, dir));
@@ -685,16 +685,14 @@ impl Ruleset {
             }
 
             ruleset.iter().any(|r| r.allows_socket(addr, dir))
-        };
-
-        is_allowed
+        }
     }
 
     /// Returns `true` if at least one rule allows querying the specific `domain` and no rule blocks it
     pub fn allows_domain(&self, domain: impl AsRef<str>) -> bool {
         let domain = domain.as_ref();
 
-        let is_allowed = {
+        {
             let ruleset = self.rules.read().unwrap();
 
             let is_blacklisted = ruleset.iter().any(|r| r.blocks_domain(domain));
@@ -703,9 +701,7 @@ impl Ruleset {
             }
 
             ruleset.iter().any(|r| r.allows_domain(domain))
-        };
-
-        is_allowed
+        }
     }
 
     /// Expands the DNS rule that allows the specified `domain` into a list of IP based
diff --git a/lib/virtual-net/src/rx_tx.rs b/lib/virtual-net/src/rx_tx.rs
index 9d5d978778..e7ba464b88 100644
--- a/lib/virtual-net/src/rx_tx.rs
+++ b/lib/virtual-net/src/rx_tx.rs
@@ -1,27 +1,22 @@
 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 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 {
@@ -40,26 +35,6 @@ 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)]
@@ -363,8 +338,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 {
@@ -418,8 +392,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 {
@@ -476,8 +449,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 {
@@ -568,7 +540,7 @@ where
                                         tracing::warn!("failed to deserialize message - {}", err);
                                         continue;
                                     }
-                                }
+                                };
                             }
                             format => {
                                 tracing::warn!("format not currently supported - {format:?}");
@@ -598,7 +570,7 @@ where
                                         tracing::warn!("failed to deserialize message - {}", err);
                                         continue;
                                     }
-                                }
+                                };
                             }
                             format => {
                                 tracing::warn!("format not currently supported - {format:?}");
@@ -621,3 +593,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 fd834fe454..7a0b8a6c6f 100644
--- a/lib/virtual-net/src/server.rs
+++ b/lib/virtual-net/src/server.rs
@@ -1,15 +1,15 @@
 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 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;
@@ -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)
@@ -1546,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;
                     }
diff --git a/lib/virtual-net/src/tcp_pair.rs b/lib/virtual-net/src/tcp_pair.rs
index 892dc289a2..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;
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 19fdda81d6..2c8d40e016 100644
--- a/lib/vm/Cargo.toml
+++ b/lib/vm/Cargo.toml
@@ -24,23 +24,24 @@ cfg-if.workspace = true
 backtrace.workspace = true
 serde = { workspace = true, features = ["derive", "rc"], optional = true }
 enum-iterator.workspace = true
-scopeguard = "1.1.0"
+scopeguard.workspace = true
 region.workspace = true
-corosensei = { version = "0.3.0" }
-fnv = "1.0.3"
+corosensei.workspace = true
+fnv.workspace = true
+parking_lot.workspace = true
 # - Optional shared dependencies.
 tracing = { workspace = true, optional = true }
-crossbeam-queue = "0.3.8"
+crossbeam-queue.workspace = true
 loupe = { workspace = true, optional = true }
 
 [target.'cfg(any(target_family = "unix", all(target_family = "windows", target_env = "gnu")))'.dependencies]
-libunwind = "1.3.3"
+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 = [
+windows-sys = { workspace = true, features = [
 	"Win32_System_Diagnostics_Debug",
 	"Win32_System_Threading",
 	"Win32_System_Kernel",
@@ -48,8 +49,8 @@ windows-sys = { version = "0.59", features = [
 ] }
 
 [build-dependencies]
-cc = "1.0"
-rustversion = "1.0"
+cc.workspace = true
+rustversion.workspace = true
 
 [badges]
 maintenance = { status = "actively-developed" }
diff --git a/lib/vm/build.rs b/lib/vm/build.rs
deleted file mode 100644
index 69ea647830..0000000000
--- a/lib/vm/build.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#[rustversion::since(1.89)]
-fn main() {
-    println!("cargo::rustc-cfg=missing_rust_probestack");
-    println!("cargo::rustc-check-cfg=cfg(missing_rust_probestack)");
-}
-
-#[rustversion::before(1.89)]
-fn main() {
-    println!("cargo::rustc-check-cfg=cfg(missing_rust_probestack)");
-}
diff --git a/lib/vm/src/exception.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/exception_ref.rs b/lib/vm/src/exception_ref.rs
deleted file mode 100644
index f092fcf47c..0000000000
--- a/lib/vm/src/exception_ref.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use std::any::Any;
-use wasmer_types::RawValue;
-
-use crate::store::InternalStoreHandle;
-
-/// Underlying object referenced by a `VMExceptionRef`.
-#[derive(Debug)]
-pub struct VMExceptionObj {
-    contents: Box<dyn Any + Send + Sync + 'static>,
-}
-
-impl VMExceptionObj {
-    /// Wraps the given value to expose it to Wasm code as an externref.
-    pub fn new(val: impl Any + Send + Sync + 'static) -> Self {
-        Self {
-            contents: Box::new(val),
-        }
-    }
-
-    #[allow(clippy::should_implement_trait)]
-    /// Returns a reference to the underlying value.
-    pub fn as_ref(&self) -> &(dyn Any + Send + Sync + 'static) {
-        &*self.contents
-    }
-}
-
-/// Represents an opaque reference to any data within WebAssembly.
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy)]
-pub struct VMExceptionRef(pub InternalStoreHandle<VMExceptionObj>);
-
-impl VMExceptionRef {
-    /// Converts the [`VMExceptionRef`] into a `RawValue`.
-    pub fn into_raw(self) -> RawValue {
-        RawValue {
-            funcref: self.0.index(),
-        }
-    }
-
-    /// Extracts a `VMExceptionRef` from a `RawValue`.
-    ///
-    /// # Safety
-    /// `raw` must be a valid `VMExceptionRef` instance.
-    pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
-        InternalStoreHandle::from_index(raw.externref).map(Self)
-    }
-}
diff --git a/lib/vm/src/extern_ref.rs b/lib/vm/src/extern_ref.rs
index b14760f9a9..dc9f882782 100644
--- a/lib/vm/src/extern_ref.rs
+++ b/lib/vm/src/extern_ref.rs
@@ -42,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/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 db23937dc6..9b4cdb21d6 100644
--- a/lib/vm/src/instance/mod.rs
+++ b/lib/vm/src/instance/mod.rs
@@ -8,21 +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::{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, VMSharedTagIndex, VMTableDefinition, VMTableImport,
-    VMTrampoline,
+    VMTrampoline, memory_copy, memory_fill, memory32_atomic_check32, memory32_atomic_check64,
 };
-use crate::{wasmer_call_trampoline, FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMTag};
-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;
@@ -35,7 +34,7 @@ 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,
@@ -113,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> {
@@ -126,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 }
     }
 
@@ -189,6 +190,7 @@ impl Instance {
     }
 
     /// 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) }
@@ -624,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));
         }
@@ -660,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));
         }
@@ -775,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));
         }
@@ -830,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
@@ -859,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 {
@@ -886,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 {
@@ -911,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 {
@@ -938,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 {
@@ -959,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
@@ -972,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))
     }
 }
 
@@ -1016,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
     ///
@@ -1051,118 +1060,120 @@ impl VMInstance {
         imports: Imports,
         vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
     ) -> Result<Self, Trap> {
-        let vmctx_tags = tags
-            .values()
-            .map(|m| VMSharedTagIndex::new(m.index() as u32))
-            .collect::<PrimaryMap<TagIndex, _>>()
-            .into_boxed_slice();
-        let vmctx_globals = finished_globals
-            .values()
-            .map(|m| m.get(context).vmglobal())
-            .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,
-                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 {},
-            };
-
-            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(
-            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(),
-        );
+                    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`.
@@ -1303,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()
     }
 
@@ -1396,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.
@@ -1436,7 +1449,7 @@ 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));
         }
@@ -1476,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.
@@ -1504,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 a8306e393e..2e7f19bb59 100644
--- a/lib/vm/src/lib.rs
+++ b/lib/vm/src/lib.rs
@@ -12,9 +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_ref;
+mod exception;
 mod export;
 mod extern_ref;
 mod function_env;
@@ -35,7 +35,7 @@ pub mod libcalls;
 
 use std::ptr::NonNull;
 
-pub use crate::exception_ref::{VMExceptionObj, VMExceptionRef};
+pub use crate::exception::{VMExceptionObj, VMExceptionRef};
 pub use crate::export::*;
 pub use crate::extern_ref::{VMExternObj, VMExternRef};
 pub use crate::function_env::VMFunctionEnvironment;
@@ -43,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;
@@ -52,7 +52,9 @@ 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,
@@ -132,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 087de16fc1..e134abee18 100644
--- a/lib/vm/src/libcalls.rs
+++ b/lib/vm/src/libcalls.rs
@@ -37,44 +37,45 @@
 
 #![allow(missing_docs)] // For some reason lint fails saying that `LibCall` is not documented, when it actually is
 
-use std::panic;
+use std::{ffi::c_void, panic};
 mod eh;
-use eh::UwExceptionWrapper;
-pub(crate) use eh::WasmerException;
-pub use eh::{wasmer_eh_personality, wasmer_eh_personality2};
 
-use crate::probestack::PROBESTACK;
-use crate::table::{RawTableElement, TableElement};
-use crate::trap::{raise_lib_trap, Trap, TrapCode};
+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};
 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 {
@@ -100,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 {
@@ -149,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)
-    })
+    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.
@@ -171,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)
-    })
+    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.
@@ -193,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.
@@ -206,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`.
@@ -222,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,
@@ -231,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);
     }
 }
 
@@ -253,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,
@@ -262,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);
+        }
     }
 }
 
@@ -278,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,
@@ -286,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);
+        }
     }
 }
 
@@ -307,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.
@@ -320,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`.
@@ -336,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)),
+        }
     }
 }
 
@@ -357,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)),
+        }
     }
 }
 
@@ -381,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);
+        }
     }
 }
 
@@ -414,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);
+        }
     }
 }
 
@@ -441,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)
-    })
+    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.
@@ -469,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)
-    })
+    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`.
@@ -496,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`.
@@ -512,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.
@@ -526,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,
@@ -534,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);
+        }
     }
 }
 
@@ -549,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,
@@ -557,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);
+        }
     }
 }
 
@@ -572,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,
@@ -580,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);
+        }
     }
 }
 
@@ -595,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,
@@ -603,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);
+        }
     }
 }
 
@@ -618,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,
@@ -627,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);
+        }
     }
 }
 
@@ -643,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
@@ -658,39 +705,16 @@ 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)
-}
-
-/// Implementation for throwing an exception.
-///
-/// # Safety
-///
-/// Calls libunwind to perform unwinding magic.
-#[no_mangle]
-pub unsafe extern "C-unwind" fn wasmer_vm_throw(
-    tag: u32,
-    vmctx: *mut VMContext,
-    data_ptr: usize,
-    data_size: u64,
-) -> ! {
-    eh::throw(tag, vmctx, data_ptr, data_size)
-}
-
-/// Implementation for throwing an exception.
-///
-/// # Safety
-///
-/// Calls libunwind to perform unwinding magic.
-#[no_mangle]
-pub unsafe extern "C-unwind" fn wasmer_vm_rethrow(exc: *mut UwExceptionWrapper) -> ! {
-    eh::rethrow(exc)
+    unsafe {
+        let trap = Trap::lib(trap_code);
+        raise_lib_trap(trap)
+    }
 }
 
 /// (debug) Print an usize.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C-unwind" fn wasmer_vm_dbg_usize(value: usize) {
     #[allow(clippy::print_stdout)]
     {
@@ -699,7 +723,7 @@ pub extern "C-unwind" fn wasmer_vm_dbg_usize(value: usize) {
 }
 
 /// (debug) Print a string.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C-unwind" fn wasmer_vm_dbg_str(ptr: usize, len: u32) {
     #[allow(clippy::print_stdout)]
     unsafe {
@@ -709,42 +733,58 @@ pub extern "C-unwind" fn wasmer_vm_dbg_str(ptr: usize, len: u32) {
     }
 }
 
-/// Implementation for allocating an exception.
-#[no_mangle]
-pub extern "C-unwind" fn wasmer_vm_alloc_exception(size: usize) -> u64 {
-    Vec::<u8>::with_capacity(size).leak().as_ptr() as usize as u64
+/// Implementation for 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 deleting the data of an exception.
+/// Implementation for allocating an exception. Returns the exnref, i.e. a handle to the
+/// exception within the store.
 ///
 /// # Safety
 ///
-/// `exception` must be dereferenceable.
-#[no_mangle]
-pub unsafe extern "C-unwind" fn wasmer_vm_delete_exception(exception: *mut WasmerException) {
-    if !exception.is_null() {
-        let size = (*exception).data_size as usize;
-        let data = Vec::<u8>::from_raw_parts((*exception).data_ptr as *mut u8, size, size);
-        std::mem::drop(data);
-    }
+/// 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 }
 }
 
-/// Implementation for reading a [`WasmerException`] from a [`UwExceptionWrapper`].
+/// Given a pointer to a caught exception, return the exnref contained within.
+///
 /// # Safety
 ///
-/// `exception` must be dereferenceable.
-#[no_mangle]
-pub unsafe extern "C-unwind" fn wasmer_vm_read_exception(
-    exception: *const UwExceptionWrapper,
-) -> *const WasmerException {
-    if !exception.is_null() {
-        if let Some(w) = (*exception).cause.downcast_ref() {
-            w as *const WasmerException
-        } else {
-            panic!()
-        }
-    } else {
-        std::ptr::null()
+/// `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
     }
 }
 
@@ -754,7 +794,7 @@ pub unsafe extern "C-unwind" fn wasmer_vm_read_exception(
 ///
 /// This function does not follow the standard function ABI, and is called as
 /// part of the function prologue.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub static WASMER_VM_PROBESTACK: unsafe extern "C" fn() = PROBESTACK;
 
 /// Implementation of memory.wait32 for locally-defined 32-bit memories.
@@ -762,7 +802,7 @@ pub static WASMER_VM_PROBESTACK: unsafe extern "C" fn() = PROBESTACK;
 /// # 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,
@@ -770,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.
@@ -787,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,
@@ -795,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.
@@ -812,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,
@@ -820,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.
@@ -837,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,
@@ -845,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.
@@ -886,73 +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::Throw => wasmer_vm_throw as usize,
-        LibCall::Rethrow => wasmer_vm_rethrow as usize,
-        LibCall::EHPersonality => wasmer_eh_personality as usize,
-        LibCall::EHPersonality2 => wasmer_eh_personality2 as usize,
-        LibCall::AllocException => wasmer_vm_alloc_exception as usize,
-        LibCall::DeleteException => wasmer_vm_delete_exception as usize,
-        LibCall::ReadException => wasmer_vm_read_exception as usize,
-        LibCall::DebugUsize => wasmer_vm_dbg_usize as usize,
-        LibCall::DebugStr => wasmer_vm_dbg_str as usize,
+        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
index 8ed7bd2086..63151248e7 100644
--- a/lib/vm/src/libcalls/eh/dwarf/eh.rs
+++ b/lib/vm/src/libcalls/eh/dwarf/eh.rs
@@ -72,14 +72,14 @@ pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(
 
 /* change to true to enable logging from the personality function */
 macro_rules! log {
-    ($e: expr) => {
+    ($e: expr_2021) => {
         if false {
             eprintln!($e)
         }
 
     };
 
-    ($($e: expr),*) => {
+    ($($e: expr_2021),*) => {
         if false {
             eprintln!($($e),*)
         }
@@ -210,7 +210,9 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result
                                         _ => panic!(),
                                     };
 
-                                    log!("(pers) new_ttype_index for action #{cs_action_entry}: {new_ttype_index:?}");
+                                    log!(
+                                        "(pers) new_ttype_index for action #{cs_action_entry}: {new_ttype_index:?}"
+                                    );
 
                                     let i = class_info.wrapping_sub(new_ttype_index as usize);
                                     log!("(pers) reading ttype info from {i:?}");
diff --git a/lib/vm/src/libcalls/eh/gcc.rs b/lib/vm/src/libcalls/eh/gcc.rs
index c79119344e..acaec81743 100644
--- a/lib/vm/src/libcalls/eh/gcc.rs
+++ b/lib/vm/src/libcalls/eh/gcc.rs
@@ -34,10 +34,12 @@
 //! out the data before returning, so further stack frames will not get stale
 //! data by mistake.
 
-use libunwind as uw;
+use std::ffi::c_void;
+
+use libunwind::{self as uw};
 use wasmer_types::TagIndex;
 
-use crate::VMContext;
+use crate::{InternalStoreHandle, StoreHandle, StoreObjects, VMContext, VMExceptionRef};
 
 use super::dwarf::eh::{self, EHAction, EHContext};
 
@@ -57,7 +59,7 @@ const NO_MATCH_FOUND_TAG_VALUE: i32 = i32::MAX - 1;
 pub struct UwExceptionWrapper {
     pub _uwe: uw::_Unwind_Exception,
     pub canary: *const u8,
-    pub cause: Box<dyn std::any::Any + Send>,
+    pub exnref: u32,
 
     // First stage -> second stage communication
     pub current_frame_info: Option<Box<CurrentFrameInfo>>,
@@ -65,51 +67,26 @@ pub struct UwExceptionWrapper {
 
 #[repr(C)]
 pub struct CurrentFrameInfo {
-    pub exception_tag: u32,
     pub catch_tags: Vec<u32>,
     pub has_catch_all: bool,
 }
 
 impl UwExceptionWrapper {
-    pub fn new(tag: u32, data_ptr: usize, data_size: u64) -> Self {
+    pub fn new(exnref: u32) -> Self {
         Self {
             _uwe: uw::_Unwind_Exception {
                 exception_class: WASMER_EXCEPTION_CLASS,
-                exception_cleanup: None,
+                exception_cleanup: Some(deallocate_exception),
                 private_1: core::ptr::null::<u8>() as usize as _,
                 private_2: 0,
             },
             canary: &CANARY,
-            cause: Box::new(WasmerException {
-                tag,
-                data_ptr,
-                data_size,
-            }),
+            exnref,
             current_frame_info: None,
         }
     }
 }
 
-#[repr(C)]
-#[derive(Debug, thiserror::Error, Clone)]
-#[error("Uncaught exception in wasm code!")]
-pub struct WasmerException {
-    // This is the store-unique tag index.
-    pub tag: u32,
-    pub data_ptr: usize,
-    pub data_size: u64,
-}
-
-impl WasmerException {
-    pub fn new(tag: u32, data_ptr: usize, data_size: u64) -> Self {
-        Self {
-            tag,
-            data_ptr,
-            data_size,
-        }
-    }
-}
-
 #[cfg(target_arch = "x86_64")]
 const UNWIND_DATA_REG: (i32, i32) = (0, 1); // RAX, RDX
 
@@ -122,7 +99,10 @@ const UNWIND_DATA_REG: (i32, i32) = (10, 11); // x10, x11
 #[cfg(target_arch = "loongarch64")]
 const UNWIND_DATA_REG: (i32, i32) = (4, 5); // a0, a1
 
-#[no_mangle]
+#[cfg(target_arch = "powerpc64")]
+const UNWIND_DATA_REG: (i32, i32) = (3, 4); // R3, R4
+
+#[unsafe(no_mangle)]
 /// The implementation of Wasmer's personality function.
 ///
 /// # Safety
@@ -148,14 +128,6 @@ pub unsafe extern "C" fn wasmer_eh_personality(
             return uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND;
         }
 
-        let wasmer_exc = (*uw_exc).cause.downcast_ref::<WasmerException>();
-        let wasmer_exc = match wasmer_exc {
-            Some(e) => e,
-            None => {
-                return uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND;
-            }
-        };
-
         let eh_action = match find_eh_action(context) {
             Ok(action) => action,
             Err(_) => {
@@ -188,7 +160,6 @@ pub unsafe extern "C" fn wasmer_eh_personality(
                 EHAction::CatchSpecific { lpad, tags }
                 | EHAction::CatchSpecificOrAll { lpad, tags } => {
                     (*uw_exc).current_frame_info = Some(Box::new(CurrentFrameInfo {
-                        exception_tag: wasmer_exc.tag,
                         catch_tags: tags,
                         has_catch_all,
                     }));
@@ -204,8 +175,8 @@ pub unsafe extern "C" fn wasmer_eh_personality(
     }
 }
 
-#[no_mangle]
-/// The second stage of the  personality function. See module level documentation
+#[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
@@ -222,9 +193,11 @@ pub unsafe extern "C" fn wasmer_eh_personality2(
         };
 
         let instance = (*vmctx).instance();
+        let exn = super::exn_obj_from_exnref(vmctx, (*exception_object).exnref);
+
         for tag in current_frame_info.catch_tags {
             let unique_tag = instance.shared_tag_ptr(TagIndex::from_u32(tag)).index();
-            if unique_tag == current_frame_info.exception_tag {
+            if unique_tag == (*exn).tag_index() {
                 return tag as i32;
             }
         }
@@ -260,39 +233,59 @@ unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction,
     }
 }
 
-pub unsafe fn throw(tag: u32, vmctx: *mut VMContext, data_ptr: usize, data_size: u64) -> ! {
-    // Look up the unique tag from the VMContext.
-    let unique_tag = (*vmctx)
-        .instance()
-        .shared_tag_ptr(TagIndex::from_u32(tag))
-        .index();
-
-    let exception = Box::new(UwExceptionWrapper::new(unique_tag, data_ptr, data_size));
-    let exception_param = Box::into_raw(exception) as *mut libunwind::_Unwind_Exception;
+pub unsafe fn read_exnref(exception: *mut c_void) -> u32 {
+    if exception.is_null() {
+        0
+    } else {
+        unsafe { (*(exception as *mut UwExceptionWrapper)).exnref }
+    }
+}
 
-    match uw::_Unwind_RaiseException(exception_param) {
-        libunwind::_Unwind_Reason_Code__URC_END_OF_STACK => {
-            crate::raise_lib_trap(crate::Trap::lib(wasmer_types::TrapCode::UncaughtException))
+/// # Safety
+///
+/// Performs libunwind unwinding magic. Highly unsafe.
+pub unsafe fn throw(ctx: &StoreObjects, exnref: u32) -> ! {
+    unsafe {
+        if exnref == 0 {
+            crate::raise_lib_trap(crate::Trap::lib(
+                wasmer_types::TrapCode::UninitializedExnRef,
+            ))
         }
-        _ => {
-            unreachable!()
+
+        let exception = Box::new(UwExceptionWrapper::new(exnref));
+        let exception_ptr = Box::into_raw(exception);
+
+        match uw::_Unwind_RaiseException(exception_ptr as *mut libunwind::_Unwind_Exception) {
+            libunwind::_Unwind_Reason_Code__URC_END_OF_STACK => {
+                delete_exception(exception_ptr as *mut c_void);
+
+                let exnref = VMExceptionRef(StoreHandle::from_internal(
+                    ctx.id(),
+                    InternalStoreHandle::from_index(exnref as usize).unwrap(),
+                ));
+                crate::raise_lib_trap(crate::Trap::uncaught_exception(exnref, ctx))
+            }
+            _ => {
+                unreachable!()
+            }
         }
     }
 }
 
-pub unsafe fn rethrow(exc: *mut UwExceptionWrapper) -> ! {
-    if exc.is_null() {
-        panic!();
+pub unsafe fn delete_exception(exception: *mut c_void) {
+    unsafe {
+        if !exception.is_null() {
+            uw::_Unwind_DeleteException(exception as *mut uw::_Unwind_Exception);
+        }
     }
+}
 
-    match uw::_Unwind_Resume_or_Rethrow(std::mem::transmute::<
-        *mut UwExceptionWrapper,
-        *mut libunwind::_Unwind_Exception,
-    >(exc))
-    {
-        libunwind::_Unwind_Reason_Code__URC_END_OF_STACK => {
-            crate::raise_lib_trap(crate::Trap::lib(wasmer_types::TrapCode::UncaughtException))
-        }
-        _ => unreachable!(),
+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
index d8d8127345..9c96a599da 100644
--- a/lib/vm/src/libcalls/eh/mod.rs
+++ b/lib/vm/src/libcalls/eh/mod.rs
@@ -1,60 +1,50 @@
 // 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"))] {
-        // We have yet to figure this out.
-        #[repr(C)]
-        pub struct UwExceptionWrapper {
-            pub _uwe: (),
-            pub cause: Box<dyn std::any::Any + Send>,
-        }
-
-        impl UwExceptionWrapper {
-            pub fn new(tag: u64, data_ptr: usize, data_size: u64) -> Self {
-                Self {
-                    _uwe: (),
-                    cause: Box::new(WasmerException {
-                        tag,
-                        data_ptr,
-                        data_size,
-                    }),
-                }
-            }
-        }
-
-        #[repr(C)]
-        #[derive(Debug, thiserror::Error, Clone)]
-        #[error("Uncaught exception in wasm code!")]
-        pub struct WasmerException {
-            pub tag: u64,
-            pub data_ptr: usize,
-            pub data_size: u64,
+        /// The implementation of Wasmer's personality function.
+        ///
+        /// # Safety
+        ///
+        /// Performs libunwind unwinding magic.
+        pub unsafe fn wasmer_eh_personality() {
+            panic!()
         }
 
-        pub fn wasmer_eh_personality() {
+        /// 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 fn wasmer_eh_personality2() {
+        pub unsafe fn read_exnref(_exception: *mut std::ffi::c_void) -> u32 {
             panic!()
         }
 
-        pub unsafe fn throw(
-            _tag: u32,
-            _vmctx: *mut crate::VMContext,
-            _data_ptr: usize,
-            _data_size: u64,
-        ) -> ! {
+        /// # Safety
+        ///
+        /// Performs libunwind unwinding magic. Highly unsafe.
+        pub unsafe fn throw(_ctx: &crate::StoreObjects, _exnref: u32) -> ! {
             panic!()
         }
 
-        pub fn rethrow(_exc: *mut UwExceptionWrapper) -> ! {
+        /// 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",
@@ -72,3 +62,10 @@ cfg_if::cfg_if! {
         // - 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 878ac7c5fb..7780943843 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,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
@@ -239,13 +243,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 +270,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 +289,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 +491,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 +512,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 +597,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 +690,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 +699,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 +749,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 +790,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 +846,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 4791ea15e8..634451764b 100644
--- a/lib/vm/src/mmap.rs
+++ b/lib/vm/src/mmap.rs
@@ -25,6 +25,7 @@ pub struct Mmap {
     ptr: usize,
     total_size: usize,
     accessible_size: usize,
+    #[cfg_attr(target_os = "windows", allow(dead_code))]
     sync_on_drop: bool,
 }
 
@@ -193,7 +194,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 +275,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 +396,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);
         }
diff --git a/lib/vm/src/probestack/mod.rs b/lib/vm/src/probestack/mod.rs
index 84dfd22fb8..5c1e978c40 100644
--- a/lib/vm/src/probestack/mod.rs
+++ b/lib/vm/src/probestack/mod.rs
@@ -16,7 +16,6 @@
 
 // Based on `compiler-builtins` crate with changes in `#[cfg(...)]`:
 // https://raw.githubusercontent.com/rust-lang/compiler-builtins/319637f544d9dda8fc3dd482d9979e0da135a258/compiler-builtins/src/probestack.rs
-#[cfg(missing_rust_probestack)]
 mod compiler_builtins;
 
 // A declaration for the stack probe function in Rust's standard library, for
@@ -27,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)
@@ -37,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"))]
@@ -60,17 +59,7 @@ cfg_if::cfg_if! {
         /// A default probestack for other architectures
         pub const PROBESTACK: unsafe extern "C" fn() = empty_probestack;
     } else {
-        cfg_if::cfg_if! {
-            if #[cfg(not(missing_rust_probestack))] {
-                extern "C" {
-                    pub fn __rust_probestack();
-                }
-                /// The probestack based on the Rust probestack
-                pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack;
-            } else if #[cfg(missing_rust_probestack)] {
-                /// The probestack based on the Rust probestack
-                pub static PROBESTACK: unsafe extern "C" fn() = compiler_builtins::__rust_probestack;
-            }
-        }
+        /// The probestack based on the Rust probestack
+        pub static PROBESTACK: unsafe extern "C" fn() = compiler_builtins::__rust_probestack;
     }
 }
diff --git a/lib/vm/src/sig_registry.rs b/lib/vm/src/sig_registry.rs
index 71d5f4b23c..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;
diff --git a/lib/vm/src/store.rs b/lib/vm/src/store.rs
index 019416d765..0611e74912 100644
--- a/lib/vm/src/store.rs
+++ b/lib/vm/src/store.rs
@@ -15,6 +15,7 @@ pub trait StoreObject: Sized {
     /// 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,)*) => {
         $(
@@ -29,6 +30,7 @@ macro_rules! impl_context_object {
         )*
     };
 }
+
 impl_context_object! {
     functions => VMFunction,
     tables => VMTable,
@@ -115,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()
     }
 
@@ -239,7 +241,7 @@ pub struct InternalStoreHandle<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)
+        std::mem::size_of_val(self)
     }
 }
 
diff --git a/lib/vm/src/table.rs b/lib/vm/src/table.rs
index 9399623914..47f49f0002 100644
--- a/lib/vm/src/table.rs
+++ b/lib/vm/src/table.rs
@@ -5,11 +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 crate::store::MaybeInstanceOwned;
+use crate::vmcontext::VMTableDefinition;
 use std::cell::UnsafeCell;
 use std::convert::TryFrom;
 use std::fmt;
@@ -106,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.
@@ -115,47 +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 _,
+                        })))
+                    },
+                }),
+            }
         }
     }
 
@@ -274,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));
         }
 
@@ -320,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 747b65ebce..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() 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 843b4c7c0a..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 {
@@ -130,6 +165,7 @@ impl fmt::Display for Trap {
             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 f3f7b9c995..9542a534b4 100644
--- a/lib/vm/src/trap/traphandlers.rs
+++ b/lib/vm/src/trap/traphandlers.rs
@@ -22,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::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>,
 }
 
@@ -93,32 +93,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),
@@ -144,7 +168,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...
@@ -161,7 +185,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!(
@@ -199,7 +223,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,
@@ -224,13 +248,13 @@ 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,
@@ -291,7 +315,7 @@ cfg_if::cfg_if! {
                     previous.sa_sigaction
                 )(signum)
             }
-        }
+        }}
 
         unsafe fn get_pc_sp(context: &ucontext_t) -> (usize, usize) {
             let (pc, sp);
@@ -315,8 +339,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",
@@ -336,14 +361,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");
                 }
@@ -375,11 +404,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;
@@ -450,12 +480,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;
@@ -472,6 +503,14 @@ cfg_if::cfg_if! {
                     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");
                 }
@@ -494,73 +533,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
             }
         }
 
@@ -632,7 +676,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.
@@ -647,7 +691,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
@@ -659,7 +703,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`.
@@ -685,16 +729,18 @@ pub unsafe fn wasmer_call_trampoline(
     callee: *const VMFunctionBody,
     values_vec: *mut u8,
 ) -> Result<(), Trap> {
-    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);
-    })
+    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`,
@@ -811,28 +857,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,
+            )
+        }
     }
 }
 
@@ -845,46 +893,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
+        }
     }
 }
 
@@ -919,14 +969,16 @@ 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
@@ -1061,53 +1113,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 09f780c500..b5d49a860e 100644
--- a/lib/vm/src/vmcontext.rs
+++ b/lib/vm/src/vmcontext.rs
@@ -4,15 +4,16 @@
 //! 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 wasmer_types::RawValue;
@@ -47,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) }
     }
 }
 
@@ -320,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,
@@ -359,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
@@ -390,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
@@ -421,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
@@ -600,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.
@@ -615,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;
@@ -663,87 +692,70 @@ 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;
-        ptrs[VMBuiltinFunctionIndex::get_imported_throw_index().index() as usize] =
-            wasmer_vm_throw as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_rethrow_index().index() as usize] =
-            wasmer_vm_rethrow as usize;
-
-        ptrs[VMBuiltinFunctionIndex::get_imported_alloc_exception_index().index() as usize] =
-            wasmer_vm_alloc_exception as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_delete_exception_index().index() as usize] =
-            wasmer_vm_delete_exception as usize;
-        ptrs[VMBuiltinFunctionIndex::get_imported_read_exception_index().index() as usize] =
-            wasmer_vm_read_exception as usize;
-
+            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 usize;
+            wasmer_vm_dbg_usize as *const () as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_debug_str_index().index() as usize] =
-            wasmer_vm_dbg_str as usize;
+            wasmer_vm_dbg_str as *const () as usize;
 
         debug_assert!(ptrs.iter().cloned().all(|p| p != 0));
 
@@ -773,12 +785,18 @@ 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)
+        }
     }
 }
 
diff --git a/lib/wai-bindgen-wasmer/Cargo.toml b/lib/wai-bindgen-wasmer/Cargo.toml
index 2d3f8f69e0..68ce0725b2 100644
--- a/lib/wai-bindgen-wasmer/Cargo.toml
+++ b/lib/wai-bindgen-wasmer/Cargo.toml
@@ -15,18 +15,18 @@ rust-version.workspace = true
 [dependencies]
 anyhow.workspace = true
 async-trait = { workspace = true, optional = true }
-bitflags = "1.2"
+bitflags.workspace = true
 once_cell.workspace = true
 thiserror.workspace = true
-tracing-lib = { version = "0.1.26", optional = true, package = "tracing" }
-wai-bindgen-wasmer-impl = { version = "0.2.2" }
+tracing = { workspace = true, optional = true }
+wai-bindgen-wasmer-impl.workspace = true
 wasmer = { version = "=6.1.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.
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 5af1b4cd34..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};
diff --git a/lib/wasi-types/Cargo.toml b/lib/wasi-types/Cargo.toml
index fcdd175f71..a30c92f9cf 100644
--- a/lib/wasi-types/Cargo.toml
+++ b/lib/wasi-types/Cargo.toml
@@ -18,24 +18,24 @@ rust-version.workspace = true
 wasmer = { default-features = false, path = "../api", version = "=6.1.0" }
 wasmer-types = { path = "../types", version = "=6.1.0" }
 wasmer-derive = { path = "../derive", version = "=6.1.0" }
-wai-bindgen-gen-rust = "0.2.1"
-wai-bindgen-rust = { version = "0.2.1", default-features = false, features = [
+wai-bindgen-gen-rust.workspace = true
+wai-bindgen-rust = { workspace = true, 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"
+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 = "1.3.0"
+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"]
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/wasix/Cargo.toml b/lib/wasix/Cargo.toml
index ac8254cd10..a46dbf9402 100644
--- a/lib/wasix/Cargo.toml
+++ b/lib/wasix/Cargo.toml
@@ -40,16 +40,16 @@ hyper = { workspace = true, features = ["server"], optional = true }
 derive_more.workspace = true
 wasm-encoder.workspace = true
 
-xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
-rusty_pool = { version = "0.7.0", optional = true }
+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 = { version = "0.1", optional = true }
+typetag = { workspace = true, optional = true }
 serde = { workspace = true, default-features = false, features = ["derive"] }
-bincode = { version = "1.3" }
-chrono = { version = "^0.4.38", default-features = false, features = [
+bincode = { workspace = true }
+chrono = { workspace = true, default-features = false, features = [
 	"wasmbind",
 	"std",
 	"clock",
@@ -57,8 +57,9 @@ chrono = { version = "^0.4.38", default-features = false, features = [
 bytes.workspace = true
 anyhow.workspace = true
 sha2.workspace = true
-waker-fn = { version = "1.1" }
-cooked-waker = "^5"
+waker-fn.workspace = true
+cooked-waker.workspace = true
+# TODO: port to newer version
 rand = "0.8"
 tokio = { workspace = true, features = [
 	"sync",
@@ -66,42 +67,42 @@ tokio = { workspace = true, features = [
 	"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 = { workspace = true }
-urlencoding = { version = "^2" }
-serde_derive = { version = "^1" }
+async-trait.workspace = true
+urlencoding.workspace = true
+serde_derive.workspace = true
 serde_json.workspace = true
-weezl = { version = "^0.1" }
+weezl.workspace = true
 hex.workspace = true
-linked_hash_set = { version = "0.1" }
-heapless = "0.8"
+linked_hash_set.workspace = true
+heapless.workspace = true
 once_cell.workspace = true
-pin-project = "1.0.12"
+pin-project.workspace = true
 semver.workspace = true
 tempfile.workspace = true
 num_enum.workspace = true
 # Used by the WCGI runner
-wcgi = { version = "0.3.0", optional = true }
-wcgi-host = { version = "0.3.0", optional = true }
-tower-http = { version = "0.5.0", features = [
+wcgi = { workspace = true, optional = true }
+wcgi-host = { workspace = true, optional = true }
+tower-http = { workspace = true, features = [
 	"trace",
 	"util",
 	"catch-panic",
 	"cors",
 ], optional = true }
-tower = { version = "0.4.13", features = ["make", "util"], optional = true }
+tower = { workspace = true, features = ["make", "util"], optional = true }
 url.workspace = true
 bytecheck.workspace = true
 blake3.workspace = true
-petgraph = "0.7.0"
-lz4_flex = { version = "0.11" }
+petgraph.workspace = true
+lz4_flex.workspace = true
 rayon = { workspace = true, optional = true }
-wasm-bindgen = { version = "0.2.87", optional = true }
-js-sys = { version = "0.3.64", optional = true }
-wasm-bindgen-futures = { version = "0.4.37", optional = true }
-web-sys = { version = "0.3.64", features = [
+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",
@@ -119,10 +120,10 @@ hyper-util = { workspace = true, features = [
 ], optional = true }
 http-body-util = { workspace = true, optional = true }
 toml.workspace = true
-pin-utils = "0.1.0"
+pin-utils.workspace = true
 wasmparser = { workspace = true }
-crossbeam-channel = "0.5.15"
-bus = "2.4.1"
+crossbeam-channel.workspace = true
+bus.workspace = true
 
 [target.'cfg(not(any(target_arch = "riscv64", target_arch = "loongarch64")))'.dependencies.reqwest]
 workspace = true
@@ -140,15 +141,15 @@ 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 = [
+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
 
 [dev-dependencies]
 wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = [
@@ -162,17 +163,17 @@ tokio = { workspace = true, features = [
 ], default-features = false }
 pretty_assertions.workspace = true
 tracing-test.workspace = true
-wasm-bindgen-test = "0.3.0"
-env_logger = { version = "0.11.5", default-features = false }
+wasm-bindgen-test.workspace = true
+env_logger = { workspace = true, default-features = false }
 log.workspace = true
-assert-panic = "1.0.1"
+assert-panic.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 = { workspace = true}
+tracing-subscriber = { workspace = true }
 wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = [
 	"wat",
 	"js-serializable-module",
@@ -220,6 +221,7 @@ sys = [
 	"ctrlc",
 	"wasmer/wat",
 	"wasmer/js-serializable-module",
+	"wasmer/experimental-async",
 ]
 sys-default = ["sys", "wasmer/sys"]
 sys-poll = []
diff --git a/lib/wasix/src/bin_factory/binary_package.rs b/lib/wasix/src/bin_factory/binary_package.rs
index 6688c712b9..ca6779fcff 100644
--- a/lib/wasix/src/bin_factory/binary_package.rs
+++ b/lib/wasix/src/bin_factory/binary_package.rs
@@ -3,18 +3,18 @@ use std::{path::Path, sync::Arc};
 use anyhow::Context;
 use once_cell::sync::OnceCell;
 use sha2::Digest;
-use virtual_fs::FileSystem;
+use virtual_fs::UnionFileSystem;
 use wasmer_config::package::{
     PackageHash, PackageId, PackageSource, SuggestedCompilerOptimizations,
 };
 use wasmer_package::package::Package;
-use webc::compat::SharedBytes;
 use webc::Container;
+use webc::compat::SharedBytes;
 
 use crate::{
+    Runtime,
     runners::MappedDirectory,
     runtime::resolver::{PackageInfo, ResolveError},
-    Runtime,
 };
 use wasmer_types::ModuleHash;
 
@@ -90,7 +90,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,
@@ -253,8 +256,7 @@ impl BinaryPackage {
                 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,
+                    "Unable to determine the package's entrypoint. Please choose one of {commands:?}"
                 );
             }
         }
@@ -265,12 +267,12 @@ impl BinaryPackage {
 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::*;
@@ -327,6 +329,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")
@@ -353,10 +357,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();
diff --git a/lib/wasix/src/bin_factory/exec.rs b/lib/wasix/src/bin_factory/exec.rs
index 947d76b60e..d077394ddb 100644
--- a/lib/wasix/src/bin_factory/exec.rs
+++ b/lib/wasix/src/bin_factory/exec.rs
@@ -1,22 +1,23 @@
+#![allow(clippy::result_large_err)]
 use std::sync::Arc;
 
 use crate::{
+    RewindState, SpawnError, WasiError, WasiRuntimeError,
     os::task::{
-        thread::{RewindResultType, WasiThreadRunGuard},
         TaskJoinHandle,
+        thread::{RewindResultType, WasiThreadRunGuard},
     },
     runtime::{
+        TaintReason,
         module_cache::HashedModuleData,
         task_manager::{
             TaskWasm, TaskWasmRecycle, TaskWasmRecycleProperties, TaskWasmRunProperties,
         },
-        TaintReason,
     },
     syscalls::rewind_ext,
-    RewindState, SpawnError, WasiError, WasiRuntimeError,
 };
 use tracing::*;
-use virtual_mio::InlineWaker;
+use virtual_mio::block_on;
 use wasmer::{Function, Memory32, Memory64, Module, RuntimeError, Store, Value};
 use wasmer_wasix_types::wasi::Errno;
 
@@ -164,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(),
@@ -373,8 +374,9 @@ fn call_module(
         match err.as_exit_code() {
             Some(s) => s,
             None => {
-                error!("{err}");
-                eprintln!("{err}");
+                let err_display = err.display(&mut store);
+                error!("{err_display}");
+                eprintln!("{err_display}");
                 Errno::Noexec.into()
             }
         }
@@ -420,7 +422,7 @@ fn resume_vfork(
             eprintln!("{err}");
         }
 
-        InlineWaker::block_on(
+        block_on(
             unsafe { ctx.data(store).get_memory_and_wasi_state(store, 0) }
                 .1
                 .fs
diff --git a/lib/wasix/src/bin_factory/mod.rs b/lib/wasix/src/bin_factory/mod.rs
index e97dbe9c72..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,
@@ -24,16 +25,16 @@ pub use self::{
     },
 };
 use crate::{
+    Runtime, SpawnError, WasiEnv,
     os::{command::Commands, task::TaskJoinHandle},
     runtime::module_cache::HashedModuleData,
-    Runtime, SpawnError, WasiEnv,
 };
 
 #[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 {
@@ -49,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)]
@@ -59,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 {
@@ -90,12 +91,12 @@ impl BinFactory {
                     spawn_exec_wasm(data, name.as_str(), env, &self.runtime).await
                 }
                 Executable::BinaryPackage(pkg) => {
-                    // Get the command that is going to be executed
-                    let cmd = package_command_by_name(&pkg, name.as_str())?;
-
-                    env.prepare_spawn(cmd);
+                    {
+                        let cmd = package_command_by_name(&pkg, name.as_str())?;
+                        env.prepare_spawn(cmd);
+                    }
 
-                    spawn_exec(pkg, name.as_str(), env, &self.runtime).await
+                    spawn_exec(pkg.as_ref().clone(), name.as_str(), env, &self.runtime).await
                 }
             }
         })
@@ -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"
+                    );
                 }
             }
         }
@@ -174,7 +174,7 @@ impl BinFactory {
 
 pub enum Executable {
     Wasm(OwnedBuffer),
-    BinaryPackage(BinaryPackage),
+    BinaryPackage(Arc<BinaryPackage>),
 }
 
 async fn load_executable_from_filesystem(
@@ -198,7 +198,7 @@ async fn load_executable_from_filesystem(
                     .await
                     .context("Unable to load the package")?;
 
-                return Ok(Executable::BinaryPackage(pkg));
+                return Ok(Executable::BinaryPackage(Arc::new(pkg)));
             }
         }
 
@@ -214,7 +214,7 @@ async fn load_executable_from_filesystem(
                 .await
                 .context("Unable to load the package")?;
 
-            Ok(Executable::BinaryPackage(pkg))
+            Ok(Executable::BinaryPackage(Arc::new(pkg)))
         } else {
             Ok(Executable::Wasm(OwnedBuffer::from_bytes(bytes)))
         }
diff --git a/lib/wasix/src/fs/fd.rs b/lib/wasix/src/fs/fd.rs
index 9242616b74..520220b9d9 100644
--- a/lib/wasix/src/fs/fd.rs
+++ b/lib/wasix/src/fs/fd.rs
@@ -2,12 +2,12 @@ use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
     path::PathBuf,
-    sync::{atomic::AtomicU64, Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard, atomic::AtomicU64},
 };
 
 use serde_derive::{Deserialize, Serialize};
 use std::sync::Mutex as StdMutex;
-use tokio::sync::{watch, Mutex as AsyncMutex};
+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};
 
@@ -74,11 +74,11 @@ pub struct InodeVal {
 }
 
 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()
     }
 }
diff --git a/lib/wasix/src/fs/fd_list.rs b/lib/wasix/src/fs/fd_list.rs
index d9901ca676..3540a55834 100644
--- a/lib/wasix/src/fs/fd_list.rs
+++ b/lib/wasix/src/fs/fd_list.rs
@@ -88,7 +88,9 @@ impl FdList {
             // 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");
+                    panic!(
+                        "Internal error in FdList - expected {after_or_equal} to be unoccupied since the list wasn't long enough"
+                    );
                 }
                 after_or_equal
             }
@@ -200,7 +202,7 @@ impl FdList {
         self.first_free = None;
     }
 
-    pub fn iter(&self) -> FdListIterator {
+    pub fn iter(&self) -> FdListIterator<'_> {
         FdListIterator {
             fds_iterator: self.fds.iter(),
             idx: 0,
@@ -211,7 +213,7 @@ impl FdList {
         self.iter().map(|(key, _)| key)
     }
 
-    pub fn iter_mut(&mut self) -> FdListIteratorMut {
+    pub fn iter_mut(&mut self) -> FdListIteratorMut<'_> {
         FdListIteratorMut {
             fds_iterator: self.fds.iter_mut(),
             idx: 0,
@@ -291,15 +293,15 @@ mod tests {
     use std::{
         borrow::Cow,
         sync::{
-            atomic::{AtomicI32, AtomicU64},
             Arc, RwLock,
+            atomic::{AtomicI32, AtomicU64},
         },
     };
 
     use assert_panic::assert_panic;
     use wasmer_wasix_types::wasi::{Fdflags, Fdflagsext, Rights};
 
-    use crate::fs::{fd::FdInner, Inode, InodeGuard, InodeVal, Kind};
+    use crate::fs::{Inode, InodeGuard, InodeVal, Kind, fd::FdInner};
 
     use super::{Fd, FdList, WasiFd};
 
diff --git a/lib/wasix/src/fs/inode_guard.rs b/lib/wasix/src/fs/inode_guard.rs
index d59e060381..5c45eaa3de 100644
--- a/lib/wasix/src/fs/inode_guard.rs
+++ b/lib/wasix/src/fs/inode_guard.rs
@@ -15,11 +15,11 @@ use wasmer_wasix_types::{
     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},
 };
 
@@ -91,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,
@@ -194,7 +194,7 @@ 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)
                 }
@@ -293,7 +293,7 @@ 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)
                 }
diff --git a/lib/wasix/src/fs/mod.rs b/lib/wasix/src/fs/mod.rs
index 16cd1da0df..1de82fc713 100644
--- a/lib/wasix/src/fs/mod.rs
+++ b/lib/wasix/src/fs/mod.rs
@@ -9,6 +9,7 @@ mod fd;
 mod fd_list;
 mod inode_guard;
 mod notification;
+pub(crate) mod relative_path_hack;
 
 use std::{
     borrow::{Borrow, Cow},
@@ -17,8 +18,8 @@ use std::{
     path::{Component, Path, PathBuf},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering},
         Arc, Mutex, RwLock, Weak,
+        atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering},
     },
     task::{Context, Poll},
 };
@@ -28,12 +29,15 @@ use crate::{
     net::socket::InodeSocketKind,
     state::{Stderr, Stdin, Stdout},
 };
-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;
 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},
@@ -46,11 +50,12 @@ use wasmer_wasix_types::{
 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
 ///
@@ -362,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,
@@ -454,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();
@@ -638,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
@@ -749,7 +786,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);
@@ -773,10 +810,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"),
@@ -823,7 +857,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);
@@ -843,10 +877,7 @@ 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"),
@@ -867,10 +898,11 @@ impl WasiFs {
 
                 {
                     let mut guard = inode.kind.write().unwrap();
-                    if let Kind::File { ref mut fd, .. } = *guard {
-                        *fd = Some(real_fd);
-                    } else {
-                        unreachable!("We just created a Kind::File");
+                    match guard.deref_mut() {
+                        Kind::File { fd, .. } => {
+                            *fd = Some(real_fd);
+                        }
+                        _ => unreachable!("We just created a Kind::File"),
                     }
                 }
 
@@ -908,7 +940,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);
@@ -921,7 +953,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);
@@ -1043,9 +1075,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() {
@@ -1133,7 +1165,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 {
@@ -1159,10 +1193,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(),
@@ -1176,7 +1207,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);
 
@@ -1188,10 +1221,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(),
@@ -1476,7 +1506,7 @@ impl WasiFs {
                     fs_flags: Fdflags::empty(),
                     fs_rights_base: STDIN_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             __WASI_STDOUT_FILENO => {
                 return Ok(Fdstat {
@@ -1484,7 +1514,7 @@ impl WasiFs {
                     fs_flags: Fdflags::APPEND,
                     fs_rights_base: STDOUT_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             __WASI_STDERR_FILENO => {
                 return Ok(Fdstat {
@@ -1492,7 +1522,7 @@ impl WasiFs {
                     fs_flags: Fdflags::APPEND,
                     fs_rights_base: STDERR_DEFAULT_RIGHTS,
                     fs_rights_inheriting: Rights::empty(),
-                })
+                });
             }
             VIRTUAL_ROOT_FD => {
                 return Ok(Fdstat {
@@ -2138,9 +2168,10 @@ impl WasiFs {
                 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`
@@ -2150,10 +2181,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),
@@ -2213,14 +2248,14 @@ impl std::fmt::Debug for WasiFs {
 }
 
 /// 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(tokio::runtime::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()
         }
     }
 }
@@ -2230,7 +2265,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`"
+        );
     }
 }
 
@@ -2259,7 +2296,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(
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/reqwest.rs b/lib/wasix/src/http/reqwest.rs
index 1959ea28c1..cbb32cb037 100644
--- a/lib/wasix/src/http/reqwest.rs
+++ b/lib/wasix/src/http/reqwest.rs
@@ -1,7 +1,7 @@
 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;
 
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 e1c5bd7b9f..e696b3ecd8 100644
--- a/lib/wasix/src/journal/effector/mod.rs
+++ b/lib/wasix/src/journal/effector/mod.rs
@@ -13,11 +13,10 @@ pub(super) use wasmer_wasix_types::{
 };
 
 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::*;
diff --git a/lib/wasix/src/journal/effector/process_exit.rs b/lib/wasix/src/journal/effector/process_exit.rs
index f831073a8e..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,7 +25,7 @@ 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);
         }
diff --git a/lib/wasix/src/journal/effector/syscalls/chdir.rs b/lib/wasix/src/journal/effector/syscalls/chdir.rs
index d23dc733dc..88001f003a 100644
--- a/lib/wasix/src/journal/effector/syscalls/chdir.rs
+++ b/lib/wasix/src/journal/effector/syscalls/chdir.rs
@@ -8,9 +8,7 @@ impl JournalEffector {
     pub fn apply_chdir(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: &str) -> anyhow::Result<()> {
         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 8c5ec8a730..d228ad0f61 100644
--- a/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
+++ b/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
@@ -8,10 +8,10 @@ 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);
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 423b9d46cb..8153c3eeae 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_close.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_close.rs
@@ -11,11 +11,7 @@ impl JournalEffector {
         // 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 6f96f2548e..e5120be9f9 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
@@ -26,11 +26,7 @@ impl JournalEffector {
         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}")
             })?;
 
         if ret_fd != copied_fd {
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 99434b2f0a..f78ac07983 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
@@ -15,7 +15,7 @@ impl JournalEffector {
         write_fd: Fd,
     ) -> anyhow::Result<()> {
         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)
+            anyhow::format_err!("journal restore error: failed to create pipe - {err}")
         })?;
 
         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
index 1dd347962e..5f32ef4818 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs
@@ -16,10 +16,7 @@ impl JournalEffector {
     ) -> anyhow::Result<()> {
         crate::syscalls::fd_fdflags_set_internal(ctx, fd, flags).map_err(|err| {
             anyhow::format_err!(
-                "journal restore error: failed to set file flags (fd={}, flags={:?}) - {}",
-                fd,
-                flags,
-                err
+                "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 d6700c3c9a..3559370d7c 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_write.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_write.rs
@@ -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 476b91ab45..17ef8b8aaf 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_open.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_open.rs
@@ -59,10 +59,7 @@ impl JournalEffector {
             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 e157c556cc..b27aa53209 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
@@ -95,8 +95,7 @@ impl JournalEffector {
             .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 9130097f9c..f12787ee66 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
@@ -85,8 +85,7 @@ impl JournalEffector {
             )
             .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
index 1dd2582413..b615a6e6f7 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_pair.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_pair.rs
@@ -20,10 +20,7 @@ impl JournalEffector {
         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
-            )
+            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 711cbb2bc4..a035caa80f 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
@@ -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 2382fdbe9e..4af85bc2e6 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
 //!
@@ -70,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;
@@ -93,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, WasiModuleInstanceHandles,
-        WasiModuleTreeHandles, 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},
     },
 };
 
@@ -283,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)
@@ -297,6 +296,28 @@ impl WasiRuntimeError {
             None
         }
     }
+
+    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 {
+            WasiRuntimeErrorDisplay::Other(self)
+        }
+    }
+}
+
+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}"),
+        }
+    }
 }
 
 #[allow(clippy::result_large_err)]
@@ -358,9 +379,8 @@ impl Clone for WasiVFork {
     }
 }
 
-/// 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>,
@@ -894,3 +914,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 4f0d5a0092..9355cd0bbc 100644
--- a/lib/wasix/src/macros.rs
+++ b/lib/wasix/src/macros.rs
@@ -50,58 +50,40 @@ 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 {
diff --git a/lib/wasix/src/net/mod.rs b/lib/wasix/src/net/mod.rs
index 1ce815a1f6..82789340ed 100644
--- a/lib/wasix/src/net/mod.rs
+++ b/lib/wasix/src/net/mod.rs
@@ -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},
 };
diff --git a/lib/wasix/src/net/socket.rs b/lib/wasix/src/net/socket.rs
index c22cad56e3..6df8a888bc 100644
--- a/lib/wasix/src/net/socket.rs
+++ b/lib/wasix/src/net/socket.rs
@@ -13,13 +13,13 @@ use std::{
 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))]
@@ -1145,13 +1145,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)),
                     };
@@ -1228,7 +1228,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 {
@@ -1333,7 +1333,7 @@ impl InodeSocket {
                             };
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         _ => return Poll::Ready(Err(Errno::Notsup)),
                     };
@@ -1421,7 +1421,7 @@ impl InodeSocket {
                             };
                         }
                         InodeSocketKind::PreSocket { .. } => {
-                            return Poll::Ready(Err(Errno::Notconn))
+                            return Poll::Ready(Err(Errno::Notconn));
                         }
                         _ => return Poll::Ready(Err(Errno::Notsup)),
                     };
@@ -1558,19 +1558,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 46bb1cfb11..4f609933a3 100644
--- a/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
+++ b/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
@@ -1,21 +1,22 @@
 use std::{any::Any, path::PathBuf, sync::Arc};
 
 use crate::{
+    SpawnError,
     bin_factory::spawn_exec_wasm,
     os::task::{OwnedTaskStatus, TaskJoinHandle},
-    runtime::{module_cache::HashedModuleData, task_manager::InlineWaker},
-    SpawnError,
+    runtime::module_cache::HashedModuleData,
 };
 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:
@@ -54,7 +55,7 @@ impl CmdWasmer {
 #[derive(Debug, Clone)]
 enum Executable {
     Wasm(OwnedBuffer),
-    BinaryPackage(BinaryPackage),
+    BinaryPackage(Box<BinaryPackage>),
 }
 
 impl CmdWasmer {
@@ -102,12 +103,12 @@ impl CmdWasmer {
                         .await
                         .unwrap();
 
-                    Executable::BinaryPackage(pkg)
+                    Executable::BinaryPackage(Box::new(pkg))
                 } else {
                     Executable::Wasm(OwnedBuffer::from_bytes(bytes))
                 }
             } else if let Ok(pkg) = self.get_package(&what).await {
-                Executable::BinaryPackage(pkg)
+                Executable::BinaryPackage(Box::new(pkg))
             } else {
                 let _ = unsafe { stderr_write(parent_ctx, HELP_RUN.as_bytes()) }.await;
                 let handle =
@@ -125,18 +126,23 @@ impl CmdWasmer {
                                 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);
+                    {
+                        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
+                    spawn_exec(*binary, name, env, &self.runtime).await
                 }
                 Executable::Wasm(bytes) => {
                     let data = HashedModuleData::new(bytes);
@@ -213,6 +219,6 @@ impl VirtualCommand for CmdWasmer {
             }
         };
 
-        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 7c9343d384..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 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.
@@ -92,7 +91,7 @@ impl Commands {
             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 - {path}\r\n").as_bytes(),
                 ))
diff --git a/lib/wasix/src/os/console/mod.rs b/lib/wasix/src/os/console/mod.rs
index ec987b6be4..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 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,12 +29,11 @@ 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},
     runners::wasi::{PackageOrHash, RuntimeOrEngine},
-    runtime::task_manager::InlineWaker,
-    Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError,
 };
 
 #[derive(Debug)]
@@ -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();
@@ -242,14 +242,14 @@ 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 {
+            block_on(async {
                 virtual_fs::AsyncWriteExt::write_all(&mut stderr, format!("{err}\r\n").as_bytes())
                     .await
                     .ok();
@@ -271,13 +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 process = InlineWaker::block_on(spawn_exec(pkg, prog, env, &self.runtime))?;
+        let process = block_on(spawn_exec(pkg, prog, env, &self.runtime))?;
 
         // Return the process
         Ok((process, wasi_process))
@@ -311,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
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 6f88ee67c2..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.
diff --git a/lib/wasix/src/os/task/process.rs b/lib/wasix/src/os/task/process.rs
index abc78f6e20..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
@@ -229,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
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 eba37607b1..799d0fcdd0 100644
--- a/lib/wasix/src/os/task/thread.rs
+++ b/lib/wasix/src/os/task/thread.rs
@@ -16,10 +16,10 @@ use wasmer_wasix_types::{
 };
 
 use crate::{
+    WasiRuntimeError,
     os::task::process::{WasiProcessId, WasiProcessInner},
     state::LinkError,
     syscalls::HandleRewindType,
-    WasiRuntimeError,
 };
 
 use super::{
@@ -470,15 +470,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 {
diff --git a/lib/wasix/src/os/tty/mod.rs b/lib/wasix/src/os/tty/mod.rs
index 6755d9fb8b..6fba0b10c0 100644
--- a/lib/wasix/src/os/tty/mod.rs
+++ b/lib/wasix/src/os/tty/mod.rs
@@ -184,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))
                     }
diff --git a/lib/wasix/src/os/tty/tty_sys.rs b/lib/wasix/src/os/tty/tty_sys.rs
index 5b661ca394..6c73c9dadb 100644
--- a/lib/wasix/src/os/tty/tty_sys.rs
+++ b/lib/wasix/src/os/tty/tty_sys.rs
@@ -77,8 +77,8 @@ mod sys_terminal_size {
 mod sys {
     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/factory.rs b/lib/wasix/src/runners/dcgi/factory.rs
index 6496f9ee9b..9bcca054de 100644
--- a/lib/wasix/src/runners/dcgi/factory.rs
+++ b/lib/wasix/src/runners/dcgi/factory.rs
@@ -4,9 +4,9 @@ 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::*;
diff --git a/lib/wasix/src/runners/dcgi/runner.rs b/lib/wasix/src/runners/dcgi/runner.rs
index 4229c98dab..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};
diff --git a/lib/wasix/src/runners/dproxy/handler.rs b/lib/wasix/src/runners/dproxy/handler.rs
index 7cc283b88c..2f90fdc1fc 100644
--- a/lib/wasix/src/runners/dproxy/handler.rs
+++ b/lib/wasix/src/runners/dproxy/handler.rs
@@ -8,11 +8,11 @@ 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(Debug)]
 pub struct SharedState {
diff --git a/lib/wasix/src/runners/dproxy/networking.rs b/lib/wasix/src/runners/dproxy/networking.rs
index 2e288e3e6d..0bcd4868fd 100644
--- a/lib/wasix/src/runners/dproxy/networking.rs
+++ b/lib/wasix/src/runners/dproxy/networking.rs
@@ -7,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)]
diff --git a/lib/wasix/src/runners/dproxy/runner.rs b/lib/wasix/src/runners/dproxy/runner.rs
index 3ff2865c82..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;
diff --git a/lib/wasix/src/runners/dproxy/socket_manager.rs b/lib/wasix/src/runners/dproxy/socket_manager.rs
index 801a96e485..6cd2bf5cab 100644
--- a/lib/wasix/src/runners/dproxy/socket_manager.rs
+++ b/lib/wasix/src/runners/dproxy/socket_manager.rs
@@ -2,15 +2,15 @@ use std::{
     future::poll_fn,
     net::{IpAddr, Ipv4Addr, SocketAddr},
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     task::{Context, Poll},
     time::Duration,
 };
 
 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>;
diff --git a/lib/wasix/src/runners/mod.rs b/lib/wasix/src/runners/mod.rs
index 03ad7ec9b8..68c59b6e5d 100644
--- a/lib/wasix/src/runners/mod.rs
+++ b/lib/wasix/src/runners/mod.rs
@@ -11,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>;
 
@@ -36,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,
     },
 };
 
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 9daf461c81..a41496d4d2 100644
--- a/lib/wasix/src/runners/wasi.rs
+++ b/lib/wasix/src/runners/wasi.rs
@@ -7,18 +7,18 @@ use tracing::Instrument;
 use virtual_fs::{ArcBoxFile, FileSystem, TmpFileSystem, VirtualFile};
 use wasmer::{Engine, Module};
 use wasmer_types::ModuleHash;
-use webc::metadata::{annotations::Wasi, Command};
+use webc::metadata::{Command, annotations::Wasi};
 
 use crate::{
+    Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
     journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
-    runners::{wasi_common::CommonWasiOptions, MappedDirectory, MountedDirectory},
+    runners::{MappedDirectory, MountedDirectory, wasi_common::CommonWasiOptions},
     runtime::task_manager::VirtualTaskManagerExt,
-    Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
 };
 
-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 {
@@ -109,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>,
@@ -197,7 +192,7 @@ impl WasiRunner {
 
     #[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")]
@@ -296,7 +291,8 @@ impl WasiRunner {
                 builder.add_webc(pkg.clone());
                 builder.set_module_hash(pkg.hash());
                 builder.include_packages(pkg.package_ids.clone());
-                Some(Arc::clone(&pkg.webc_fs))
+
+                pkg.webc_fs.as_deref().map(|fs| fs.duplicate())
             }
             PackageOrHash::Hash(hash) => {
                 builder.set_module_hash(hash);
@@ -380,8 +376,8 @@ impl WasiRunner {
             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 writable journal file"
-                        ));
+                        "If you specify a snapshot interval then you must also specify a writable journal file"
+                    ));
                 }
                 builder.with_snapshot_interval(period);
             }
@@ -411,7 +407,7 @@ impl WasiRunner {
                     weak.upgrade()
                         .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}")))
                         })
                 })
             })
@@ -481,8 +477,8 @@ impl WasiRunner {
             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"
-                        ));
+                        "If you specify a snapshot interval then you must also specify a journal file"
+                    ));
                 }
                 builder.with_snapshot_interval(period);
             }
@@ -521,9 +517,7 @@ impl WasiRunner {
                             weak.upgrade()
                                 .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}")))
                                 })
                         })
                     })
diff --git a/lib/wasix/src/runners/wasi_common.rs b/lib/wasix/src/runners/wasi_common.rs
index c585d8bd78..2dd326a0a5 100644
--- a/lib/wasix/src/runners/wasi_common.rs
+++ b/lib/wasix/src/runners/wasi_common.rs
@@ -5,16 +5,18 @@ use std::{
 };
 
 use anyhow::{Context, Error};
-use futures::future::BoxFuture;
 use tokio::runtime::Handle;
-use virtual_fs::{FileSystem, FsError, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem};
+use virtual_fs::{
+    FileSystem, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem, UnionFileSystem,
+};
 use webc::metadata::annotations::Wasi as WasiAnnotation;
 
 use crate::{
+    WasiEnvBuilder,
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
+    fs::{WasiFsRoot, relative_path_hack::RelativeOrAbsolutePathHack},
     journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
-    WasiEnvBuilder,
 };
 
 pub const MAPPED_CURRENT_DIR_DEFAULT_PATH: &str = "/home";
@@ -36,7 +38,6 @@ pub(crate) struct CommonWasiOptions {
     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,
     pub(crate) read_only_journals: Vec<Arc<DynReadableJournal>>,
@@ -52,7 +53,7 @@ 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> {
@@ -61,9 +62,12 @@ impl CommonWasiOptions {
         }
 
         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)?;
 
@@ -76,7 +80,7 @@ impl CommonWasiOptions {
 
         builder.add_preopen_dir("/")?;
 
-        builder.set_fs(Box::new(fs));
+        builder.set_fs_root(fs);
 
         for pkg in &self.injected_packages {
             builder.add_webc(pkg.clone());
@@ -197,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)?;
     }
@@ -215,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)
@@ -307,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 wasmer_package::utils::from_bytes;
+    use virtual_fs::{DirEntry, FileType, Metadata};
 
     use super::*;
 
@@ -414,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(),
@@ -422,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!(
@@ -450,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!(
@@ -466,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() {
@@ -477,27 +395,39 @@ mod tests {
             guest: "/home".to_string(),
             host: sub_dir,
         })];
-        let 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/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 265cfc9d92..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,
@@ -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
diff --git a/lib/wasix/src/runners/wcgi/runner.rs b/lib/wasix/src/runners/wcgi/runner.rs
index 62acb54a96..d9626ac428 100644
--- a/lib/wasix/src/runners/wcgi/runner.rs
+++ b/lib/wasix/src/runners/wcgi/runner.rs
@@ -2,26 +2,26 @@ use std::{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,
 };
 
 use super::Callbacks;
@@ -70,12 +70,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 +102,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()
@@ -312,7 +313,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")]
diff --git a/lib/wasix/src/runtime/mod.rs b/lib/wasix/src/runtime/mod.rs
index 7fd6616fe9..a288e0f0a3 100644
--- a/lib/wasix/src/runtime/mod.rs
+++ b/lib/wasix/src/runtime/mod.rs
@@ -3,8 +3,8 @@ pub mod package_loader;
 pub mod resolver;
 pub mod task_manager;
 
+use self::module_cache::CacheError;
 pub use self::task_manager::{SpawnType, VirtualTaskManager};
-use self::{module_cache::CacheError, task_manager::InlineWaker};
 use module_cache::HashedModuleData;
 use wasmer_config::package::SuggestedCompilerOptimizations;
 use wasmer_types::target::UserCompilerOptimizations as WasmerSuggestedCompilerOptimizations;
@@ -16,6 +16,7 @@ use std::{
 };
 
 use futures::future::BoxFuture;
+use virtual_mio::block_on;
 use virtual_net::{DynVirtualNetworking, VirtualNetworking};
 use wasmer::{CompileError, Engine, Module, RuntimeError};
 use wasmer_wasix_types::wasi::ExitCode;
@@ -23,6 +24,7 @@ use wasmer_wasix_types::wasi::ExitCode;
 #[cfg(feature = "journal")]
 use crate::journal::{DynJournal, DynReadableJournal};
 use crate::{
+    SpawnError, WasiTtyState,
     bin_factory::BinaryPackageCommand,
     http::{DynHttpClient, HttpClient},
     os::TtyBridge,
@@ -31,7 +33,6 @@ use crate::{
         package_loader::{PackageLoader, UnsupportedPackageLoader},
         resolver::{BackendSource, MultiSource, Source},
     },
-    SpawnError, WasiTtyState,
 };
 
 #[derive(Clone)]
@@ -133,7 +134,7 @@ where
                         module_hash: *data.hash(),
                         error,
                     })
-                })
+                });
             }
         };
 
@@ -144,7 +145,7 @@ where
 
     /// Sync version of [`Self::load_command_module`].
     fn load_command_module_sync(&self, cmd: &BinaryPackageCommand) -> Result<Module, SpawnError> {
-        InlineWaker::block_on(self.load_command_module(cmd))
+        block_on(self.load_command_module(cmd))
     }
 
     /// Load a WebAssembly module from raw bytes.
@@ -169,7 +170,7 @@ where
     )]
     fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError> {
         #[allow(deprecated)]
-        InlineWaker::block_on(self.load_module(wasm))
+        block_on(self.load_module(wasm))
     }
 
     /// Load a WebAssembly module from pre-hashed data.
@@ -192,7 +193,7 @@ where
         wasm: HashedModuleData,
         engine: Option<&Engine>,
     ) -> Result<Module, SpawnError> {
-        InlineWaker::block_on(self.load_hashed_module(wasm, engine))
+        block_on(self.load_hashed_module(wasm, engine))
     }
 
     /// Callback thats invokes whenever the instance is tainted, tainting can occur
@@ -667,7 +668,7 @@ impl Runtime for OverriddenRuntime {
     fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError> {
         #[allow(deprecated)]
         if self.engine.is_some() || self.module_cache.is_some() {
-            InlineWaker::block_on(self.load_module(wasm))
+            block_on(self.load_module(wasm))
         } else {
             self.inner.load_module_sync(wasm)
         }
@@ -694,7 +695,7 @@ impl Runtime for OverriddenRuntime {
         engine: Option<&Engine>,
     ) -> Result<Module, SpawnError> {
         if self.engine.is_some() || self.module_cache.is_some() {
-            InlineWaker::block_on(self.load_hashed_module(wasm, engine))
+            block_on(self.load_hashed_module(wasm, engine))
         } else {
             self.inner.load_hashed_module_sync(wasm, engine)
         }
diff --git a/lib/wasix/src/runtime/module_cache/hashed_module.rs b/lib/wasix/src/runtime/module_cache/hashed_module.rs
index 092899456a..29b1f68f19 100644
--- a/lib/wasix/src/runtime/module_cache/hashed_module.rs
+++ b/lib/wasix/src/runtime/module_cache/hashed_module.rs
@@ -8,7 +8,7 @@ use crate::bin_factory::BinaryPackageCommand;
 /// Allows passing around WASM code and it's hash without the danger of
 /// using a wrong hash.
 ///
-/// Safe by construction: can only be created from a [`BinaryCommand`], which
+/// 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.
 ///
@@ -38,7 +38,7 @@ impl HashedModuleData {
         Self { hash, wasm }
     }
 
-    /// Create new [`HashedModuleData`] from the given [`BinaryPackageCommand`].
+    /// 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 {
diff --git a/lib/wasix/src/runtime/module_cache/types.rs b/lib/wasix/src/runtime/module_cache/types.rs
index 2cb1bc96cd..a053b412be 100644
--- a/lib/wasix/src/runtime/module_cache/types.rs
+++ b/lib/wasix/src/runtime/module_cache/types.rs
@@ -51,6 +51,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,
     /// };
@@ -62,6 +64,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
diff --git a/lib/wasix/src/runtime/package_loader/builtin_loader.rs b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
index c5e0931b89..942750b2dd 100644
--- a/lib/wasix/src/runtime/package_loader/builtin_loader.rs
+++ b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
@@ -165,13 +165,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)
@@ -298,19 +298,19 @@ 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",
-                        );
-                    }
+        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",
+                    );
                 }
             }
         }
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 743fb8ac39..d8f5dd4ed6 100644
--- a/lib/wasix/src/runtime/package_loader/load_package_tree.rs
+++ b/lib/wasix/src/runtime/package_loader/load_package_tree.rs
@@ -6,10 +6,10 @@ 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 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;
@@ -62,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(),
@@ -81,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,
@@ -235,15 +239,14 @@ fn extract_suggested_compiler_opts_from_atom_metadata(
     if let Some(sco) = atom_metadata
         .annotations
         .get(SuggestedCompilerOptimizations::KEY)
-    {
-        if let Some((_, v)) = sco.as_map().and_then(|v| {
+        && 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.pass_params = v.as_bool()
     }
 
     ret
@@ -399,18 +402,15 @@ 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 = None;
@@ -424,17 +424,31 @@ fn filesystem(
             )
         })?;
 
-        if container.version() == webc::Version::V2 && found_v2.is_none() {
-            found_v2 = Some(package.clone());
-        }
-        if container.version() == webc::Version::V3 && found_v3.is_none() {
-            found_v3 = Some(package.clone());
+        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}");
+            }
         }
     }
 
     match (found_v2, found_v3) {
-        (None, Some(_)) => filesystem_v3(packages, pkg, root_is_local_dir),
-        (Some(_), None) => filesystem_v2(packages, pkg, root_is_local_dir),
+        (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}"
@@ -449,7 +463,7 @@ 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();
@@ -491,9 +505,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.
@@ -523,13 +535,14 @@ 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,
         volume_name,
@@ -562,7 +575,7 @@ fn filesystem_v2(
             format!("The \"{package}\" package doesn't have a \"{volume_name}\" volume")
         })?;
 
-        let mount_path = mount_path.clone();
+        let mount_path_clone = mount_path.clone();
         // Get a filesystem which will map "$mount_dir/some-path" to
         // "$original_path/some-path" on the original volume
         let fs = if let Some(original) = original_path {
@@ -572,7 +585,7 @@ fn filesystem_v2(
                 WebcVolumeFileSystem::new(volume.clone()),
                 Box::new(move |path: &Path| {
                     let without_mount_dir = path
-                        .strip_prefix(&mount_path)
+                        .strip_prefix(&mount_path_clone)
                         .map_err(|_| virtual_fs::FsError::BaseNotDirectory)?;
                     Ok(original.join(without_mount_dir))
                 }) as DynPathMapper,
@@ -582,26 +595,21 @@ fn filesystem_v2(
                 WebcVolumeFileSystem::new(volume.clone()),
                 Box::new(move |path: &Path| {
                     let without_mount_dir = path
-                        .strip_prefix(&mount_path)
+                        .strip_prefix(&mount_path_clone)
                         .map_err(|_| virtual_fs::FsError::BaseNotDirectory)?;
                     Ok(without_mount_dir.to_owned())
                 }) 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(Box::new(fs))
+    Ok(union_fs)
 }
 
 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,
@@ -673,7 +681,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)
     }
 
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/resolver/backend_source.rs b/lib/wasix/src/runtime/resolver/backend_source.rs
index 89e4a2016a..00aff1a844 100644
--- a/lib/wasix/src/runtime/resolver/backend_source.rs
+++ b/lib/wasix/src/runtime/resolver/backend_source.rs
@@ -257,7 +257,7 @@ impl Source for BackendSource {
             _ => {
                 return Err(QueryError::Unsupported {
                     query: package.clone(),
-                })
+                });
             }
         };
 
@@ -290,14 +290,14 @@ impl Source for BackendSource {
             .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(
@@ -565,14 +565,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);
@@ -705,18 +697,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 0b977e37e6..cbda4f9c7a 100644
--- a/lib/wasix/src/runtime/resolver/filesystem_source.rs
+++ b/lib/wasix/src/runtime/resolver/filesystem_source.rs
@@ -57,7 +57,7 @@ impl Source for FileSystemSource {
             _ => {
                 return Err(QueryError::Unsupported {
                     query: package.clone(),
-                })
+                });
             }
         };
 
diff --git a/lib/wasix/src/runtime/resolver/in_memory_source.rs b/lib/wasix/src/runtime/resolver/in_memory_source.rs
index 1e97b0da0c..cbd97dcad5 100644
--- a/lib/wasix/src/runtime/resolver/in_memory_source.rs
+++ b/lib/wasix/src/runtime/resolver/in_memory_source.rs
@@ -189,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 2e54f7252c..ad115f87d0 100644
--- a/lib/wasix/src/runtime/resolver/inputs.rs
+++ b/lib/wasix/src/runtime/resolver/inputs.rs
@@ -11,7 +11,7 @@ use sha2::{Digest, Sha256};
 use url::Url;
 use wasmer_config::package::{NamedPackageId, PackageHash, PackageId, PackageSource};
 use wasmer_package::utils::from_disk;
-use webc::metadata::{annotations::Wapm as WapmAnnotations, Manifest, UrlOrManifest};
+use webc::metadata::{Manifest, UrlOrManifest, annotations::Wapm as WapmAnnotations};
 
 /// A dependency constraint.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -294,10 +294,10 @@ impl WebcHash {
         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()));
             }
         }
 
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 815dc168a9..981e35c51b 100644
--- a/lib/wasix/src/runtime/resolver/multi_source.rs
+++ b/lib/wasix/src/runtime/resolver/multi_source.rs
@@ -75,17 +75,17 @@ impl Source for MultiSource {
                 Err(QueryError::Unsupported { .. })
                     if self.strategy.continue_if_unsupported || self.strategy.merge_results =>
                 {
-                    continue
+                    continue;
                 }
                 Err(QueryError::NotFound { .. })
                     if self.strategy.continue_if_not_found || self.strategy.merge_results =>
                 {
-                    continue
+                    continue;
                 }
                 Err(QueryError::NoMatches { .. })
                     if self.strategy.continue_if_no_matches || self.strategy.merge_results =>
                 {
-                    continue
+                    continue;
                 }
                 // Generic errors do not respect the `merge_results` strategy
                 // flag, because unexpected errors should be bubbled to the
diff --git a/lib/wasix/src/runtime/resolver/resolve.rs b/lib/wasix/src/runtime/resolver/resolve.rs
index fd54312883..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;
@@ -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::*;
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 110893fe1c..2448175c6c 100644
--- a/lib/wasix/src/runtime/resolver/web_source.rs
+++ b/lib/wasix/src/runtime/resolver/web_source.rs
@@ -137,19 +137,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)
@@ -263,7 +262,7 @@ impl Source for WebSource {
             _ => {
                 return Err(QueryError::Unsupported {
                     query: package.clone(),
-                })
+                });
             }
         };
 
@@ -341,13 +340,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 {
@@ -386,7 +385,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;
@@ -394,7 +393,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 0b490f608d..2a6457ebc4 100644
--- a/lib/wasix/src/runtime/task_manager/mod.rs
+++ b/lib/wasix/src/runtime/task_manager/mod.rs
@@ -16,7 +16,7 @@ use wasmer::{
 use wasmer_wasix_types::wasi::{Errno, ExitCode};
 
 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::*;
@@ -42,7 +42,7 @@ pub enum SpawnType<'a> {
 /// # Note
 ///
 /// This type is necessary for now because we can't pass a [`wasmer::StoreRef`] between threads, so this
-/// conceptually is a Send-able [`SpawnMemoryType`].
+/// conceptually is a Send-able [`SpawnMemoryTypeOrStore`].
 pub enum SpawnMemoryTypeOrStore {
     New,
     Type(wasmer::MemoryType),
diff --git a/lib/wasix/src/runtime/task_manager/tokio.rs b/lib/wasix/src/runtime/task_manager/tokio.rs
index 9946d1784b..7da09198e9 100644
--- a/lib/wasix/src/runtime/task_manager/tokio.rs
+++ b/lib/wasix/src/runtime/task_manager/tokio.rs
@@ -1,13 +1,13 @@
 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::InlineWaker;
+use virtual_mio::block_on;
 use wasmer::AsStoreMut;
 
 use crate::runtime::SpawnType;
-use crate::{os::task::thread::WasiThreadError, WasiFunctionEnv};
+use crate::{WasiFunctionEnv, os::task::thread::WasiThreadError};
 
 use super::{SpawnMemoryTypeOrStore, TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
 
@@ -29,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))
         }
     }
 }
@@ -293,7 +293,7 @@ impl VirtualTaskManager for TokioTaskManager {
                 };
 
                 if let Some(pre_run) = pre_run {
-                    InlineWaker::block_on(pre_run(&mut ctx, &mut store));
+                    block_on(pre_run(&mut ctx, &mut store));
                 }
 
                 // Invoke the callback
diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs
index d7e5977178..4f2c7745b1 100644
--- a/lib/wasix/src/state/builder.rs
+++ b/lib/wasix/src/state/builder.rs
@@ -15,13 +15,13 @@ use wasmer_config::package::PackageId;
 #[cfg(feature = "journal")]
 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::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
-    Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiThreadError,
 };
 use wasmer_types::ModuleHash;
 use wasmer_wasix_types::wasi::SignalDisposition;
@@ -698,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
     }
 
@@ -783,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() {
@@ -812,19 +816,19 @@ impl WasiEnvBuilder {
                 Some(InvalidCharacter::Nul) => {
                     return Err(WasiStateCreationError::EnvironmentVariableFormatError(
                         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 \"{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)",
@@ -843,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) {
@@ -914,7 +918,7 @@ 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: std::sync::Mutex::new(self.args.clone()),
             preopen: self.vfs_preopens.clone(),
diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs
index b16dbdb6d6..739adccdf3 100644
--- a/lib/wasix/src/state/env.rs
+++ b/lib/wasix/src/state/env.rs
@@ -10,6 +10,7 @@ use std::{
 use futures::future::BoxFuture;
 use rand::Rng;
 use virtual_fs::{FileSystem, FsError, VirtualFile};
+use virtual_mio::block_on;
 use virtual_net::DynVirtualNetworking;
 use wasmer::{
     AsStoreMut, AsStoreRef, ExportError, FunctionEnvMut, Instance, Memory, MemoryType, MemoryView,
@@ -26,6 +27,8 @@ use webc::metadata::annotations::Wasi;
 #[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},
@@ -35,15 +38,12 @@ use crate::{
         process::{WasiProcess, WasiProcessId},
         thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId},
     },
-    runtime::task_manager::InlineWaker,
     syscalls::platform_clock_time_get,
-    Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
-    WasiResult, WasiRuntimeError, WasiStateCreationError, WasiThreadError, WasiVFork,
 };
 use wasmer_types::ModuleHash;
 
 pub use super::handles::*;
-use super::{conv_env_vars, Linker, WasiState};
+use super::{Linker, WasiState, conv_env_vars};
 
 /// Data required to construct a [`WasiEnv`].
 #[derive(Debug)]
@@ -93,7 +93,7 @@ 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(),
@@ -559,17 +559,16 @@ impl WasiEnv {
         }
 
         // 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(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from(
-                        err,
-                    ))));
-                }
-            }
+        if call_initialize
+            && let Ok(initialize) = instance.exports.get_function("_initialize")
+            && let Err(err) = crate::run_wasi_func_start(initialize, &mut store)
+        {
+            func_env
+                .data(&store)
+                .blocking_on_exit(Some(Errno::Noexec.into()));
+            return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from(
+                err,
+            ))));
         }
 
         Ok((instance, func_env))
@@ -614,11 +613,11 @@ impl WasiEnv {
         ctx: &mut FunctionEnvMut<'_, Self>,
         fast: bool,
     ) -> Result<(), WasiError> {
-        if let Some(linker) = ctx.data().inner().linker().cloned() {
-            if let Err(e) = linker.do_pending_link_operations(ctx, fast) {
-                tracing::warn!(err = ?e, "Failed to process pending link operations");
-                return Err(WasiError::Exit(Errno::Noexec.into()));
-            }
+        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(())
     }
@@ -986,7 +985,7 @@ impl WasiEnv {
         store: &'a impl AsStoreRef,
         _mem_index: u32,
     ) -> (MemoryView<'a>, &'a WasiState) {
-        let memory = self.memory_view(store);
+        let memory = unsafe { self.memory_view(store) };
         let state = self.state.deref();
         (memory, state)
     }
@@ -1001,7 +1000,7 @@ impl WasiEnv {
         store: &'a impl AsStoreRef,
         _mem_index: u32,
     ) -> (MemoryView<'a>, &'a WasiState, &'a WasiInodes) {
-        let memory = self.memory_view(store);
+        let memory = unsafe { self.memory_view(store) };
         let state = self.state.deref();
         let inodes = &state.inodes;
         (memory, state, inodes)
@@ -1014,7 +1013,7 @@ impl WasiEnv {
     }
 
     pub fn use_package(&self, pkg: &BinaryPackage) -> Result<(), WasiStateCreationError> {
-        InlineWaker::block_on(self.use_package_async(pkg))
+        block_on(self.use_package_async(pkg))
     }
 
     /// Make all the commands in a [`BinaryPackage`] available to the WASI
@@ -1084,6 +1083,32 @@ impl WasiEnv {
                             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 [{}] - {}",
+                                pkg.id,
+                                command.name(),
+                                err
+                            );
+                            continue;
+                        }
+                    }
                     WasiFsRoot::Backing(fs) => {
                         // FIXME: we're counting on the fs being a mem_fs here. Otherwise, memory
                         // usage will be very high.
@@ -1106,8 +1131,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.as_os_str().to_string_lossy().as_ref(), package);
+                    .set_binary(path.to_string_lossy().as_ref(), &package_arc);
+                self.bin_factory
+                    .set_binary(path2.to_string_lossy().as_ref(), &package_arc);
 
                 tracing::debug!(
                     package=%pkg.id,
@@ -1135,13 +1163,11 @@ impl WasiEnv {
                     "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}",
-                    ))
-                },
-            )?;
+            let pkg = block_on(BinaryPackage::from_registry(&specifier, rt)).map_err(|e| {
+                WasiStateCreationError::WasiIncludePackageError(format!(
+                    "package_name={package_name}, {e}",
+                ))
+            })?;
             self.use_package(&pkg)?;
         }
 
@@ -1194,7 +1220,10 @@ impl WasiEnv {
                     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;
             }
         }
@@ -1205,7 +1234,7 @@ impl WasiEnv {
     #[allow(clippy::await_holding_lock)]
     pub fn blocking_on_exit(&self, process_exit_code: Option<ExitCode>) {
         let cleanup = self.on_exit(process_exit_code);
-        InlineWaker::block_on(cleanup);
+        block_on(cleanup);
     }
 
     /// Cleans up all the open files (if this is the main thread)
@@ -1221,10 +1250,10 @@ impl WasiEnv {
                 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, process_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);
             }
         }
 
diff --git a/lib/wasix/src/state/func_env.rs b/lib/wasix/src/state/func_env.rs
index 4d3a2e29f4..914edc2be0 100644
--- a/lib/wasix/src/state/func_env.rs
+++ b/lib/wasix/src/state/func_env.rs
@@ -10,11 +10,11 @@ use crate::os::task::thread::RewindResultType;
 #[cfg(feature = "journal")]
 use crate::syscalls::restore_snapshot;
 use crate::{
+    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, WasiModuleInstanceHandles,
-    WasiRuntimeError, WasiThreadError,
 };
 
 use super::Linker;
@@ -228,17 +228,15 @@ impl WasiFunctionEnv {
                         };
                         // 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
-                        }
+                        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");
+                            tracing::warn!(
+                                "Missing both __stack_low and __data_end exports, unwinding may cause memory corruption"
+                            );
                         }
                         0
                     };
@@ -389,7 +387,7 @@ impl WasiFunctionEnv {
 
                 for journal in restore_ro_journals {
                     let ctx = self.env.clone().into_mut(&mut store);
-                    let rewind = match restore_snapshot(ctx, journal.as_ref(), true) {
+                    let rewind = match unsafe { restore_snapshot(ctx, journal.as_ref(), true) } {
                         Ok(r) => r,
                         Err(err) => {
                             tracing::trace!("replaying journal=false (err={:?})", err);
@@ -402,11 +400,9 @@ impl WasiFunctionEnv {
 
                 for journal in restore_w_journals {
                     let ctx = self.env.clone().into_mut(&mut store);
-                    let rewind = match restore_snapshot(
-                        ctx,
-                        journal.as_ref().as_dyn_readable_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);
diff --git a/lib/wasix/src/state/handles/mod.rs b/lib/wasix/src/state/handles/mod.rs
index 26e000dede..1873ec055d 100644
--- a/lib/wasix/src/state/handles/mod.rs
+++ b/lib/wasix/src/state/handles/mod.rs
@@ -249,9 +249,9 @@ impl WasiModuleTreeHandles {
     /// through the `Linker` to retrieve the one they need.
     pub(crate) fn main_module_instance_handles(&self) -> &WasiModuleInstanceHandles {
         match self {
-            WasiModuleTreeHandles::Static(ref handles) => handles,
+            WasiModuleTreeHandles::Static(handles) => handles,
             WasiModuleTreeHandles::Dynamic {
-                ref main_module_instance_handles,
+                main_module_instance_handles,
                 ..
             } => main_module_instance_handles,
         }
@@ -260,9 +260,9 @@ impl WasiModuleTreeHandles {
     /// See comments on `main_module_instance_handles`.
     pub(crate) fn main_module_instance_handles_mut(&mut self) -> &mut WasiModuleInstanceHandles {
         match self {
-            WasiModuleTreeHandles::Static(ref mut handles) => handles,
+            WasiModuleTreeHandles::Static(handles) => handles,
             WasiModuleTreeHandles::Dynamic {
-                ref mut main_module_instance_handles,
+                main_module_instance_handles,
                 ..
             } => main_module_instance_handles,
         }
@@ -272,7 +272,7 @@ impl WasiModuleTreeHandles {
     /// See comments on ensure_static_module for more details.
     pub(crate) fn static_module_instance_handles(&self) -> Option<&WasiModuleInstanceHandles> {
         match self {
-            WasiModuleTreeHandles::Static(ref handles) => Some(handles),
+            WasiModuleTreeHandles::Static(handles) => Some(handles),
             WasiModuleTreeHandles::Dynamic { .. } => None,
         }
     }
@@ -283,7 +283,7 @@ impl WasiModuleTreeHandles {
         &mut self,
     ) -> Option<&mut WasiModuleInstanceHandles> {
         match self {
-            WasiModuleTreeHandles::Static(ref mut handles) => Some(handles),
+            WasiModuleTreeHandles::Static(handles) => Some(handles),
             WasiModuleTreeHandles::Dynamic { .. } => None,
         }
     }
diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs
index 0cb2c21914..731f9ec4e2 100644
--- a/lib/wasix/src/state/linker.rs
+++ b/lib/wasix/src/state/linker.rs
@@ -265,8 +265,8 @@ use std::{
     ops::{Deref, DerefMut},
     path::{Path, PathBuf},
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc, Barrier, Mutex, MutexGuard, RwLock, RwLockWriteGuard, TryLockError,
+        atomic::{AtomicBool, Ordering},
     },
 };
 
@@ -275,19 +275,19 @@ use derive_more::Debug;
 use shared_buffer::OwnedBuffer;
 use tracing::trace;
 use virtual_fs::{AsyncReadExt, FileSystem, FsError};
-use virtual_mio::InlineWaker;
+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, WasmTypeList, WASM_PAGE_SIZE,
+    Value, WASM_PAGE_SIZE, WasmTypeList,
 };
 use wasmer_wasix_types::wasix::WasiMemoryLayout;
 
 use crate::{
-    fs::WasiFsRoot, import_object_for_all_wasi_versions, runtime::module_cache::HashedModuleData,
     Runtime, SpawnError, WasiEnv, WasiError, WasiFs, WasiFunctionEnv, WasiModuleTreeHandles,
-    WasiProcess, WasiThreadId,
+    WasiProcess, WasiThreadId, fs::WasiFsRoot, import_object_for_all_wasi_versions,
+    runtime::module_cache::HashedModuleData,
 };
 
 use super::{WasiModuleInstanceHandles, WasiState};
@@ -296,7 +296,6 @@ use super::{WasiModuleInstanceHandles, WasiState};
 pub static MAIN_MODULE_HANDLE: ModuleHandle = ModuleHandle(1);
 static INVALID_MODULE_HANDLE: ModuleHandle = ModuleHandle(u32::MAX);
 
-static MAIN_MODULE_MEMORY_BASE: u64 = 0;
 // Need to keep the zeroth index null to catch null function pointers at runtime
 static MAIN_MODULE_TABLE_BASE: u64 = 1;
 
@@ -445,9 +444,7 @@ impl MemoryAllocator {
 
         trace!(
             page_count = to_grow,
-            size,
-            base_ptr,
-            "Allocated new memory page(s) to accommodate requested memory"
+            size, base_ptr, "Allocated new memory page(s) to accommodate requested memory"
         );
 
         Ok(base_ptr)
@@ -518,8 +515,8 @@ pub enum LinkError {
     #[error("Failed to initialize WASI(X) module handles: {0}")]
     MainModuleHandleInitFailed(ExportError),
 
-    #[error("Dynamic function index {0} was not allocated via `allocate_function`")]
-    DynamicFunctionIndexNotAllocated(u32),
+    #[error("Bad __tls_base export, expected a global of type I32 or I64")]
+    BadTlsBaseExport,
 }
 
 #[derive(Debug)]
@@ -797,7 +794,7 @@ struct DlInstance {
 
 struct InstanceGroupState {
     main_instance: Option<Instance>,
-    main_instance_tls_base: u64,
+    main_instance_tls_base: Option<u64>,
 
     side_instances: HashMap<ModuleHandle, DlInstance>,
 
@@ -821,6 +818,7 @@ struct LinkerState {
 
     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
@@ -1008,6 +1006,10 @@ impl Linker {
             "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()
@@ -1027,15 +1029,15 @@ impl Linker {
         };
 
         let stack_low = {
-            let data_end = dylink_section.mem_info.memory_size as u64;
-            if data_end % 1024 != 0 {
+            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 % 1024 != 0 {
+        if !stack_size.is_multiple_of(1024) {
             panic!("Stack size must be 1024-bit aligned");
         }
 
@@ -1047,6 +1049,7 @@ impl Linker {
 
         trace!(
             memory_pages = ?memory.grow(store, 0).unwrap(),
+            memory_base,
             stack_low,
             stack_high,
             "Memory layout"
@@ -1071,9 +1074,9 @@ impl Linker {
 
         let mut instance_group = InstanceGroupState {
             main_instance: None,
-            // Every main instance's TLS area is at the start of its memory,
-            // which is 0 for the main module's main instance
-            main_instance_tls_base: MAIN_MODULE_MEMORY_BASE,
+            // 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(),
@@ -1088,6 +1091,7 @@ impl Linker {
             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,
@@ -1103,7 +1107,7 @@ impl Linker {
         let mut link_state = InProgressLinkState::default();
 
         let well_known_imports = [
-            ("env", "__memory_base", MAIN_MODULE_MEMORY_BASE),
+            ("env", "__memory_base", memory_base),
             ("env", "__table_base", MAIN_MODULE_TABLE_BASE),
             ("GOT.mem", "__stack_high", stack_high),
             ("GOT.mem", "__stack_low", stack_low),
@@ -1139,6 +1143,9 @@ impl Linker {
         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,
@@ -1192,7 +1199,7 @@ impl Linker {
             stack_upper: stack_high,
             stack_size: stack_high - stack_low,
             guard_size: 0,
-            tls_base: Some(MAIN_MODULE_MEMORY_BASE),
+            tls_base,
         };
         let module_handles = WasiModuleTreeHandles::Dynamic {
             linker: linker.clone(),
@@ -1214,17 +1221,26 @@ impl Linker {
             )
             .map_err(LinkError::MainModuleHandleInitFailed)?;
 
-        // The main module isn't added to the link state's list of new modules, so we need to
-        // call its initialization functions separately
-        trace!("Calling data relocator function for main module");
-        call_initialization_function::<()>(&main_instance, store, "__wasm_apply_data_relocs")?;
-        call_initialization_function::<()>(&main_instance, store, "__wasm_apply_tls_relocs")?;
-
         {
-            let group_guard = linker.instance_group_state.lock().unwrap();
+            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();
-            trace!("Finalizing linking of main module");
-            linker.finalize_link_operation(group_guard, &mut linker_state, store, link_state)?;
+
+            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");
@@ -1336,7 +1352,7 @@ impl Linker {
 
         let mut instance_group = InstanceGroupState {
             main_instance: None,
-            main_instance_tls_base: tls_base,
+            main_instance_tls_base: Some(tls_base),
             side_instances: HashMap::new(),
             stack_pointer,
             memory: memory.clone(),
@@ -1350,7 +1366,7 @@ impl Linker {
         let mut pending_resolutions = PendingResolutionsFromLinker::default();
 
         let well_known_imports = [
-            ("env", "__memory_base", MAIN_MODULE_MEMORY_BASE),
+            ("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),
@@ -1674,6 +1690,18 @@ impl Linker {
             &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()
@@ -1725,37 +1753,37 @@ impl Linker {
 
         lock_instance_group_state!(guard, group_state, self, ResolveError::InstanceGroupIsDead);
 
-        if let Ok(linker_state) = self.linker_state.try_read() {
-            if let Some(resolution) = linker_state.symbol_resolution_records.get(&resolution_key) {
-                trace!(?resolution, "Already have a resolution for this symbol");
-                match resolution {
-                    SymbolResolutionResult::FunctionPointer {
-                        function_table_index: addr,
-                        ..
-                    } => {
-                        return Ok(ResolvedExport::Function {
-                            func_ptr: *addr as u64,
-                        })
-                    }
-                    SymbolResolutionResult::Memory(addr) => {
-                        return Ok(ResolvedExport::Global { data_ptr: *addr })
-                    }
-                    SymbolResolutionResult::Tls {
-                        resolved_from,
-                        offset,
-                    } => {
-                        let Some(tls_base) = group_state.tls_base(*resolved_from) else {
-                            return Err(ResolveError::TlsSymbolWithoutTls);
-                        };
-                        return Ok(ResolvedExport::Global {
-                            data_ptr: tls_base + offset,
-                        });
-                    }
-                    r => panic!(
-                        "Internal error: unexpected symbol resolution \
-                        {r:?} for requested symbol {symbol}"
-                    ),
+        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::TlsSymbolWithoutTls);
+                    };
+                    return Ok(ResolvedExport::Global {
+                        data_ptr: tls_base + offset,
+                    });
+                }
+                r => panic!(
+                    "Internal error: unexpected symbol resolution \
+                        {r:?} for requested symbol {symbol}"
+                ),
             }
         }
 
@@ -2027,7 +2055,7 @@ impl LinkerState {
 
     fn memory_base(&self, module_handle: ModuleHandle) -> u64 {
         if module_handle == MAIN_MODULE_HANDLE {
-            MAIN_MODULE_MEMORY_BASE
+            self.main_module_memory_base
         } else {
             self.side_modules
                 .get(&module_handle)
@@ -2295,7 +2323,7 @@ impl LinkerState {
                 module_spec,
                 ld_library_path,
             } => {
-                let (full_path, bytes) = InlineWaker::block_on(locate_module(
+                let (full_path, bytes) = block_on(locate_module(
                     module_spec,
                     ld_library_path,
                     runtime_path,
@@ -2400,7 +2428,7 @@ impl InstanceGroupState {
     fn tls_base(&self, module_handle: ModuleHandle) -> Option<u64> {
         if module_handle == MAIN_MODULE_HANDLE {
             // Main's TLS area is at the beginning of its memory
-            Some(self.main_instance_tls_base)
+            self.main_instance_tls_base
         } else {
             self.side_instances
                 .get(&module_handle)
@@ -2439,7 +2467,7 @@ impl InstanceGroupState {
             let current_size = self.indirect_function_table.size(store);
             let alignment = 2_u32.pow(table_alignment);
 
-            let offset = if current_size % alignment != 0 {
+            let offset = if !current_size.is_multiple_of(alignment) {
                 alignment - (current_size % alignment)
             } else {
                 0
@@ -2552,8 +2580,7 @@ impl InstanceGroupState {
 
         trace!(
             memory_base,
-            table_base,
-            "Allocated memory and table for module"
+            table_base, "Allocated memory and table for module"
         );
 
         let mut imports = import_object_for_all_wasi_versions(&pending_module.module, store, env);
@@ -2604,12 +2631,15 @@ impl InstanceGroupState {
             table_base,
         };
 
+        let tls_base = get_tls_base_export(&instance, store)?;
+
         let dl_instance = DlInstance {
             instance: instance.clone(),
             instance_handles,
-            // The TLS area of a side module's main instance is at the beginning
-            // of its memory
-            tls_base: Some(memory_base),
+            // 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);
@@ -2812,7 +2842,9 @@ impl InstanceGroupState {
             .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}");
+            panic!(
+                "Internal error: allocated index {allocated_index} does not match expected index {index}"
+            );
         }
         Ok(())
     }
@@ -2864,19 +2896,13 @@ impl InstanceGroupState {
         linker_state: &LinkerState,
     ) -> Result<(), LinkError> {
         for (key, val) in &linker_state.symbol_resolution_records {
-            if let SymbolResolutionKey::Requested { name, .. } = key {
-                if let SymbolResolutionResult::FunctionPointer {
+            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,
-                    )?;
-                }
+            {
+                self.apply_resolved_function(store, name, *resolved_from, *function_table_index)?;
             }
         }
         Ok(())
@@ -3505,7 +3531,7 @@ impl InstanceGroupState {
                         instance,
                         &linker_state.main_module_dylink_info,
                         linker_state.memory_base(MAIN_MODULE_HANDLE),
-                        Some(self.main_instance_tls_base),
+                        self.main_instance_tls_base,
                         allow_hidden,
                     ) {
                         Ok(export) => return Ok((export, MAIN_MODULE_HANDLE)),
@@ -3636,6 +3662,7 @@ impl InstanceGroupState {
 
         let ty = ty.clone();
         let resolved: Mutex<Option<Option<Function>>> = Mutex::new(None);
+
         Function::new_with_env(
             store,
             env,
@@ -3669,8 +3696,7 @@ impl InstanceGroupState {
                             Ok(guard) => {
                                 trace!(
                                     ?requesting_module,
-                                    name,
-                                    "Locked linker state successfully"
+                                    name, "Locked linker state successfully"
                                 );
                                 Some(guard)
                             }
@@ -3708,8 +3734,7 @@ impl InstanceGroupState {
                             }) => {
                                 trace!(
                                     ?requesting_module,
-                                    name,
-                                    "Function was already resolved in the linker"
+                                    name, "Function was already resolved in the linker"
                                 );
 
                                 if ty != *resolved_ty {
@@ -3798,7 +3823,9 @@ impl InstanceGroupState {
                 drop(resolved_guard);
 
                 let mut store = env.as_store_mut();
-                func.call(&mut store, params).map(|ret| ret.into())
+                func.call(&mut store, params)
+                    .map(|ret| ret.into())
+                    .map_err(crate::flatten_runtime_error)
             },
         )
     }
@@ -3894,7 +3921,7 @@ impl InstanceGroupState {
                         unresolved.import_module().to_string(),
                         key.import_name.clone(),
                         Box::new(ResolveError::MissingExport),
-                    ))
+                    ));
                 }
 
                 // Missing weak symbols get resolved to a null address
@@ -3912,7 +3939,7 @@ impl InstanceGroupState {
                         "GOT.mem".to_string(),
                         key.import_name.clone(),
                         Box::new(e),
-                    ))
+                    ));
                 }
             }
         }
@@ -4235,6 +4262,21 @@ fn call_initialization_function<Ret: WasmTypeList>(
     }
 }
 
+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};
diff --git a/lib/wasix/src/state/mod.rs b/lib/wasix/src/state/mod.rs
index f3eca94bad..18637cee3e 100644
--- a/lib/wasix/src/state/mod.rs
+++ b/lib/wasix/src/state/mod.rs
@@ -45,7 +45,7 @@ pub use self::{
 };
 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,
 };
@@ -205,7 +205,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()
     }
 
diff --git a/lib/wasix/src/syscalls/journal/actions/close_thread.rs b/lib/wasix/src/syscalls/journal/actions/close_thread.rs
index 8f41267132..5ccb857c08 100644
--- a/lib/wasix/src/syscalls/journal/actions/close_thread.rs
+++ b/lib/wasix/src/syscalls/journal/actions/close_thread.rs
@@ -16,7 +16,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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/mod.rs b/lib/wasix/src/syscalls/journal/actions/mod.rs
index 90ca821535..38dcbda799 100644
--- a/lib/wasix/src/syscalls/journal/actions/mod.rs
+++ b/lib/wasix/src/syscalls/journal/actions/mod.rs
@@ -20,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::{JournalStdIoWrite, 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;
diff --git a/lib/wasix/src/syscalls/journal/actions/process_exit.rs b/lib/wasix/src/syscalls/journal/actions/process_exit.rs
index 0740442063..a6f6cf9915 100644
--- a/lib/wasix/src/syscalls/journal/actions/process_exit.rs
+++ b/lib/wasix/src/syscalls/journal/actions/process_exit.rs
@@ -13,7 +13,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
             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/snapshot.rs b/lib/wasix/src/syscalls/journal/actions/snapshot.rs
index b62720a580..649960a3ef 100644
--- a/lib/wasix/src/syscalls/journal/actions/snapshot.rs
+++ b/lib/wasix/src/syscalls/journal/actions/snapshot.rs
@@ -30,7 +30,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
         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/update_memory.rs b/lib/wasix/src/syscalls/journal/actions/update_memory.rs
index 60edbacb3b..c839a8794b 100644
--- a/lib/wasix/src/syscalls/journal/actions/update_memory.rs
+++ b/lib/wasix/src/syscalls/journal/actions/update_memory.rs
@@ -24,8 +24,10 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
             });
         } 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/play_event.rs b/lib/wasix/src/syscalls/journal/play_event.rs
index c6fd33d78d..92a9d709f5 100644
--- a/lib/wasix/src/syscalls/journal/play_event.rs
+++ b/lib/wasix/src/syscalls/journal/play_event.rs
@@ -11,13 +11,13 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
     ) -> 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> JournalSyscallPlayer<'a, '_> {
                 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> JournalSyscallPlayer<'a, '_> {
                         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> JournalSyscallPlayer<'a, '_> {
                 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,17 +103,19 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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,
-                    Fdflagsext::empty(),
-                )?;
+                unsafe {
+                    self.action_fd_open(
+                        fd,
+                        dirfd,
+                        dirflags,
+                        path,
+                        o_flags,
+                        fs_rights_base,
+                        fs_rights_inheriting,
+                        fs_flags,
+                        Fdflagsext::empty(),
+                    )
+                }?;
             }
             JournalEntry::OpenFileDescriptorV2 {
                 fd,
@@ -123,17 +129,19 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 fd_flags,
             } => {
                 self.real_fd.insert(fd);
-                self.action_fd_open(
-                    fd,
-                    dirfd,
-                    dirflags,
-                    path,
-                    o_flags,
-                    fs_rights_base,
-                    fs_rights_inheriting,
-                    fs_flags,
-                    fd_flags,
-                )?;
+                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);
@@ -162,7 +170,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 .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");
@@ -171,12 +179,12 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
             }
             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 {
@@ -184,7 +192,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 copied_fd,
             } => {
                 if self.real_fd.contains(&original_fd) {
-                    self.action_fd_dup(original_fd, copied_fd, false)?;
+                    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 {
@@ -192,7 +200,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         copied_fd,
                     });
                 } else {
-                    self.action_fd_dup(original_fd, copied_fd, false)?;
+                    unsafe { self.action_fd_dup(original_fd, copied_fd, false) }?;
                 }
             }
             JournalEntry::DuplicateFileDescriptorV2 {
@@ -201,7 +209,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 cloexec,
             } => {
                 if self.real_fd.contains(&original_fd) {
-                    self.action_fd_dup(original_fd, copied_fd, cloexec)?;
+                    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 {
@@ -210,7 +218,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         cloexec,
                     });
                 } else {
-                    self.action_fd_dup(original_fd, copied_fd, cloexec)?;
+                    unsafe { self.action_fd_dup(original_fd, copied_fd, cloexec) }?;
                 }
             }
             JournalEntry::CreateDirectoryV1 { fd, path } => {
@@ -227,7 +235,9 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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 {
@@ -239,7 +249,9 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         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 {
@@ -249,9 +261,15 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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,
@@ -259,37 +277,37 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         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) {
-                    self.action_fd_set_fdflags(fd, flags)?;
+                    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 {
-                    self.action_fd_set_fdflags(fd, flags)?;
+                    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 {
@@ -298,7 +316,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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 {
@@ -307,7 +325,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         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 {
@@ -317,7 +335,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                 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 {
@@ -327,12 +345,12 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         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 {
@@ -341,7 +359,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                         len,
                     });
                 } else {
-                    self.action_fd_allocate(fd, offset, len)?;
+                    unsafe { self.action_fd_allocate(fd, offset, len) }?;
                 }
             }
             JournalEntry::CreateHardLinkV1 {
@@ -421,7 +439,7 @@ impl<'a> JournalSyscallPlayer<'a, '_> {
                     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 } => {
diff --git a/lib/wasix/src/syscalls/journal/restore_snapshot.rs b/lib/wasix/src/syscalls/journal/restore_snapshot.rs
index 70ba4672b0..10368c4740 100644
--- a/lib/wasix/src/syscalls/journal/restore_snapshot.rs
+++ b/lib/wasix/src/syscalls/journal/restore_snapshot.rs
@@ -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
@@ -75,7 +75,7 @@ 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)?;
     }
 
diff --git a/lib/wasix/src/syscalls/legacy/snapshot0.rs b/lib/wasix/src/syscalls/legacy/snapshot0.rs
index 30a9384da4..047d092144 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,12 +9,11 @@ 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
@@ -22,11 +23,7 @@ pub fn fd_filestat_get(
     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
@@ -39,13 +36,7 @@ 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
@@ -81,6 +72,7 @@ pub fn poll_oneoff<M: MemorySize>(
 
     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());
diff --git a/lib/wasix/src/syscalls/mod.rs b/lib/wasix/src/syscalls/mod.rs
index 03e09d75c0..e00857224e 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};
@@ -22,10 +27,11 @@ pub mod wasix;
 
 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 +42,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 +52,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,
@@ -95,14 +102,30 @@ pub(crate) use self::types::{
     *,
 };
 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::{
@@ -112,27 +135,10 @@ pub(crate) use crate::{
     },
     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, WasiModuleTreeHandles,
-    WasiVFork,
-};
-use crate::{
-    fs::{
-        fs_error_into_wasi_err, virtual_file_type_to_wasi_file_type, Fd, FdInner, InodeVal, Kind,
-        MAX_SYMLINKS,
-    },
-    journal::{DynJournal, DynReadableJournal, DynWritableJournal, 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};
 
@@ -241,7 +247,7 @@ pub unsafe fn stderr_write<'a>(
     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 mut stderr = WasiInodes::stderr_mut(&state.fs.fd_map).map_err(fs_error_into_wasi_err);
@@ -293,7 +299,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
@@ -550,7 +556,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
@@ -570,7 +576,7 @@ where
 
     // 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
@@ -623,7 +629,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
@@ -659,7 +665,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),
     }
@@ -776,7 +782,7 @@ where
                 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 {
@@ -833,10 +839,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;
     }
@@ -885,7 +891,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)
 }
 
@@ -1135,14 +1141,15 @@ 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
@@ -1301,28 +1308,30 @@ 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));
@@ -1333,7 +1342,9 @@ pub fn rewind_ext<M: MemorySize>(
     {
         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;
     }
 
@@ -1384,7 +1395,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 {
@@ -1402,7 +1413,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()
 }
 
@@ -1434,7 +1445,9 @@ where
         {
             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);
         }
 
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_sizes_get.rs b/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
index 28fef44a7a..48aeec31a0 100644
--- a/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
+++ b/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
@@ -20,13 +20,15 @@ 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
-        .lock()
-        .unwrap()
-        .len()
-        .try_into()
-        .map_err(|_| Errno::Overflow));
+    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));
diff --git a/lib/wasix/src/syscalls/wasi/clock_time_get.rs b/lib/wasix/src/syscalls/wasi/clock_time_get.rs
index 434bd95f26..2a77e9a4e6 100644
--- a/lib/wasix/src/syscalls/wasi/clock_time_get.rs
+++ b/lib/wasix/src/syscalls/wasi/clock_time_get.rs
@@ -10,14 +10,14 @@ use crate::syscalls::*;
 /// 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)
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_close.rs b/lib/wasix/src/syscalls/wasi/fd_close.rs
index 41d2711939..17b6162ec3 100644
--- a/lib/wasix/src/syscalls/wasi/fd_close.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_close.rs
@@ -22,11 +22,12 @@ pub fn fd_close(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errn
     // We don't want to allow programs that blindly close all FDs in a loop
     // to be able to close pre-opens, as that breaks wasix-libc in rather
     // spectacular fashion.
-    if let Ok(pfd) = state.fs.get_fd(fd) {
-        if !pfd.is_stdio && pfd.inode.is_preopened {
-            trace!("Skipping fd_close for pre-opened FD ({})", fd);
-            return Ok(Errno::Success);
-        }
+    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
diff --git a/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs b/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
index 328c29fb45..cebf193be1 100644
--- a/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
@@ -7,11 +7,11 @@ use crate::types::wasi::Snapshot0Filestat;
 ///
 /// 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
+///   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>,
@@ -39,11 +39,11 @@ pub fn fd_filestat_get<M: MemorySize>(
 ///
 /// 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,
@@ -63,11 +63,11 @@ pub(crate) fn fd_filestat_get_internal(
 ///
 /// 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
+///   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>,
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 98b21872b6..c87082d53d 100644
--- a/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
@@ -24,9 +24,11 @@ pub fn fd_prestat_dir_name<M: MemorySize>(
             // TODO: verify this: null termination, etc
             let path_len: u64 = path_len.into();
             if (name.len() as u64) < path_len {
-                wasi_try_mem!(path_chars
-                    .subslice(0..name.len() as u64)
-                    .write_slice(name.as_bytes()));
+                wasi_try_mem!(
+                    path_chars
+                        .subslice(0..name.len() as u64)
+                        .write_slice(name.as_bytes())
+                );
                 wasi_try_mem!(path_chars.index(name.len() as u64).write(0));
 
                 //trace!("=> result: \"{}\"", inode_val.name);
diff --git a/lib/wasix/src/syscalls/wasi/fd_readdir.rs b/lib/wasix/src/syscalls/wasi/fd_readdir.rs
index 6039c659d7..20fa956f77 100644
--- a/lib/wasix/src/syscalls/wasi/fd_readdir.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_readdir.rs
@@ -47,22 +47,26 @@ 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_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)>, _>>());
+                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();
diff --git a/lib/wasix/src/syscalls/wasi/fd_seek.rs b/lib/wasix/src/syscalls/wasi/fd_seek.rs
index 31cfe43eee..5723cf9389 100644
--- a/lib/wasix/src/syscalls/wasi/fd_seek.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_seek.rs
@@ -76,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)
             }
@@ -90,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 {
diff --git a/lib/wasix/src/syscalls/wasi/fd_write.rs b/lib/wasix/src/syscalls/wasi/fd_write.rs
index b5bb1f3f47..d5bcd3bc71 100644
--- a/lib/wasix/src/syscalls/wasi/fd_write.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_write.rs
@@ -284,15 +284,17 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                     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.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 write_result = std::io::Write::write(tx, buf.as_ref());
                                 let local_written = match write_result {
@@ -341,15 +343,17 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                     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.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 write_result = std::io::Write::write(pipe, buf.as_ref());
                                 let local_written = match write_result {
@@ -401,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() {
@@ -456,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;
@@ -489,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::from(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();
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 025427c47f..6625317b91 100644
--- a/lib/wasix/src/syscalls/wasi/path_create_directory.rs
+++ b/lib/wasix/src/syscalls/wasi/path_create_directory.rs
@@ -73,11 +73,7 @@ pub(crate) fn path_create_directory_internal(
 
     let mut guard = parent_inode.write();
     match guard.deref_mut() {
-        Kind::Dir {
-            ref entries,
-            ref path,
-            ..
-        } => {
+        Kind::Dir { entries, path, .. } => {
             if let Some(child) = entries.get(&dir_name) {
                 return Err(Errno::Exist);
             }
@@ -116,10 +112,7 @@ pub(crate) fn path_create_directory_internal(
             // reborrow to insert
             {
                 let mut guard = parent_inode.write();
-                let Kind::Dir {
-                    ref mut entries, ..
-                } = guard.deref_mut()
-                else {
+                let Kind::Dir { entries, .. } = guard.deref_mut() else {
                     unreachable!();
                 };
 
diff --git a/lib/wasix/src/syscalls/wasi/path_remove_directory.rs b/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
index 4419bb0a83..c1ea391b20 100644
--- a/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
+++ b/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
@@ -54,7 +54,7 @@ pub(crate) fn path_remove_directory_internal(
     let mut guard = parent_inode.write();
     match guard.deref_mut() {
         Kind::Dir {
-            entries: ref mut parent_entries,
+            entries: parent_entries,
             ..
         } => {
             let Some(child_inode) = parent_entries.get(&dir_name) else {
diff --git a/lib/wasix/src/syscalls/wasi/path_rename.rs b/lib/wasix/src/syscalls/wasi/path_rename.rs
index bd880afb2e..4b41ad991b 100644
--- a/lib/wasix/src/syscalls/wasi/path_rename.rs
+++ b/lib/wasix/src/syscalls/wasi/path_rename.rs
@@ -77,9 +77,11 @@ pub fn path_rename_internal(
     }
 
     // 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));
+    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
@@ -145,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);
@@ -166,14 +168,14 @@ pub fn path_rename_internal(
                     }
                 } else {
                     let mut guard = source_entry.write();
-                    if let Kind::File { ref mut path, .. } = guard.deref_mut() {
+                    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;
@@ -234,15 +236,11 @@ fn rename_inode_tree(inode: &InodeGuard, source_dir_path: &Path, target_dir_path
 
     let mut guard = inode.write();
     match guard.deref_mut() {
-        Kind::File { ref mut path, .. } => {
+        Kind::File { path, .. } => {
             *path = adjust_path(path, source_dir_path, target_dir_path);
             return;
         }
-        Kind::Dir {
-            ref mut path,
-            entries,
-            ..
-        } => {
+        Kind::Dir { path, entries, .. } => {
             *path = adjust_path(path, source_dir_path, target_dir_path);
             children = entries.values().cloned().collect::<Vec<_>>();
         }
diff --git a/lib/wasix/src/syscalls/wasi/path_symlink.rs b/lib/wasix/src/syscalls/wasi/path_symlink.rs
index 4fa7e3b9f4..617182fd51 100644
--- a/lib/wasix/src/syscalls/wasi/path_symlink.rs
+++ b/lib/wasix/src/syscalls/wasi/path_symlink.rs
@@ -127,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 12d0fb2db7..712640708b 100644
--- a/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
+++ b/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
@@ -66,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 5466fc419a..6ab51e67eb 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.
@@ -64,7 +64,7 @@ pub fn poll_oneoff<M: MemorySize + 'static>(
     nsubscriptions: M::Offset,
     nevents: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    WasiEnv::do_pending_operations(&mut ctx)?;
+    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)?);
@@ -203,15 +203,15 @@ pub(crate) fn poll_fd_guard(
 ///
 /// 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)>,
@@ -220,6 +220,8 @@ pub(crate) fn poll_oneoff_internal<'a, M: MemorySize, After>(
 where
     After: FnOnce(&FunctionEnvMut<'a, WasiEnv>, Vec<Event>) -> Errno,
 {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
     let pid = ctx.data().pid();
     let tid = ctx.data().tid();
     let subs_len = subs.len();
@@ -317,8 +319,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)
diff --git a/lib/wasix/src/syscalls/wasi/proc_exit.rs b/lib/wasix/src/syscalls/wasi/proc_exit.rs
index fadb46b0d2..9932ecb503 100644
--- a/lib/wasix/src/syscalls/wasi/proc_exit.rs
+++ b/lib/wasix/src/syscalls/wasi/proc_exit.rs
@@ -26,7 +26,7 @@ pub fn proc_exit<M: MemorySize>(
         );
 
         // Prepare the child env for teardown by closing its FDs
-        InlineWaker::block_on(
+        block_on(
             unsafe { ctx.data().get_memory_and_wasi_state(&ctx, 0) }
                 .1
                 .fs
diff --git a/lib/wasix/src/syscalls/wasix/call_dynamic.rs b/lib/wasix/src/syscalls/wasix/call_dynamic.rs
index b31387c069..5762f18148 100644
--- a/lib/wasix/src/syscalls/wasix/call_dynamic.rs
+++ b/lib/wasix/src/syscalls/wasix/call_dynamic.rs
@@ -69,25 +69,6 @@ fn read_value(
     }
 }
 
-fn flatten_runtime_error(err: RuntimeError) -> RuntimeError {
-    let e_ref = err.downcast_ref::<WasiRuntimeError>();
-    match e_ref {
-        Some(WasiRuntimeError::Wasi(_)) => {
-            let Ok(WasiRuntimeError::Wasi(err)) = err.downcast::<WasiRuntimeError>() else {
-                unreachable!()
-            };
-            RuntimeError::user(Box::new(err))
-        }
-        Some(WasiRuntimeError::Runtime(_)) => {
-            let Ok(WasiRuntimeError::Runtime(err)) = err.downcast::<WasiRuntimeError>() else {
-                unreachable!()
-            };
-            flatten_runtime_error(err)
-        }
-        _ => err,
-    }
-}
-
 /// Call a function from the `__indirect_function_table` with parameters and results from memory.
 ///
 /// This function can be used to call functions whose types are not known at
@@ -136,10 +117,11 @@ pub fn call_dynamic<M: MemorySize>(
 
     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 = wasi_try_ok!(
+        env.inner()
+            .indirect_function_table_lookup(&mut store, function_id)
+            .map_err(Errno::from)
+    );
 
     let function_type = function.ty(&store);
 
@@ -167,7 +149,7 @@ pub fn call_dynamic<M: MemorySize>(
 
     let result_values = function
         .call(&mut store, values_buffer.as_slice())
-        .map_err(flatten_runtime_error)?;
+        .map_err(crate::flatten_runtime_error)?;
 
     let memory = unsafe { env.memory_view(&store) };
     let mut current_results_offset: u64 = results.offset().into();
diff --git a/lib/wasix/src/syscalls/wasix/closure_prepare.rs b/lib/wasix/src/syscalls/wasix/closure_prepare.rs
index 8e81d50ec1..c84a1daf83 100644
--- a/lib/wasix/src/syscalls/wasix/closure_prepare.rs
+++ b/lib/wasix/src/syscalls/wasix/closure_prepare.rs
@@ -14,7 +14,7 @@ use wasm_encoder::{
     CodeSection, CustomSection, ExportKind, ExportSection, FunctionSection, GlobalType,
     ImportSection, InstructionSink, MemArg, MemoryType, RefType, TableType, TypeSection, ValType,
 };
-use wasmer::{imports, FunctionType, Table, Type};
+use wasmer::{FunctionType, Table, Type, imports};
 
 use wasmer_wasix_types::wasi::WasmValueType;
 
@@ -334,28 +334,30 @@ pub fn closure_prepare<M: MemorySize>(
 
     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 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 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!(
diff --git a/lib/wasix/src/syscalls/wasix/epoll_create.rs b/lib/wasix/src/syscalls/wasix/epoll_create.rs
index 4c9a43345d..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;
diff --git a/lib/wasix/src/syscalls/wasix/epoll_ctl.rs b/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
index f53914040f..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()`
@@ -95,45 +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_guard =
-                        wasi_try_ok_ok!(register_epoll_handler(&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) {
-                        if let Some(fd_guard) = fd_guard {
-                            subs.1.push(fd_guard);
-                        }
-                    }
+                // 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(()))
diff --git a/lib/wasix/src/syscalls/wasix/epoll_wait.rs b/lib/wasix/src/syscalls/wasix/epoll_wait.rs
index 812ca4f8e4..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;
diff --git a/lib/wasix/src/syscalls/wasix/futex_wake.rs b/lib/wasix/src/syscalls/wasix/futex_wake.rs
index 6160f872cd..ae2020df99 100644
--- a/lib/wasix/src/syscalls/wasix/futex_wake.rs
+++ b/lib/wasix/src/syscalls/wasix/futex_wake.rs
@@ -28,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);
diff --git a/lib/wasix/src/syscalls/wasix/mod.rs b/lib/wasix/src/syscalls/wasix/mod.rs
index 0ec461deab..9f1d2b81f4 100644
--- a/lib/wasix/src/syscalls/wasix/mod.rs
+++ b/lib/wasix/src/syscalls/wasix/mod.rs
@@ -172,4 +172,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
index 1a797664fa..a593a74c88 100644
--- a/lib/wasix/src/syscalls/wasix/path_open2.rs
+++ b/lib/wasix/src/syscalls/wasix/path_open2.rs
@@ -217,10 +217,7 @@ pub(crate) fn path_open_internal(
 
         match deref_mut {
             Kind::File {
-                ref mut handle,
-                path,
-                fd,
-                ..
+                handle, path, fd, ..
             } => {
                 if let Some(special_fd) = fd {
                     // short circuit if we're dealing with a special file
@@ -381,17 +378,16 @@ pub(crate) fn path_open_internal(
                     path: new_file_host_path,
                     fd: None,
                 };
-                wasi_try_ok_ok!(state
-                    .fs
-                    .create_inode(inodes, kind, false, new_entity_name.clone()))
+                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()
-                {
+                if let Kind::Dir { entries, .. } = guard.deref_mut() {
                     entries.insert(new_entity_name, new_inode.clone());
                 }
             }
diff --git a/lib/wasix/src/syscalls/wasix/port_route_list.rs b/lib/wasix/src/syscalls/wasix/port_route_list.rs
index 628cd5204c..942da7afaa 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_list.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_list.rs
@@ -21,9 +21,11 @@ pub fn port_route_list<M: MemorySize>(
     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/proc_exec3.rs b/lib/wasix/src/syscalls/wasix/proc_exec3.rs
index e72cdd7c7f..d26d732d00 100644
--- a/lib/wasix/src/syscalls/wasix/proc_exec3.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_exec3.rs
@@ -2,9 +2,9 @@ use wasmer::FromToNativeWasmType;
 
 use super::*;
 use crate::{
+    VIRTUAL_ROOT_FD, WasiFs,
     os::task::{OwnedTaskStatus, TaskStatus},
     syscalls::*,
-    WasiFs, VIRTUAL_ROOT_FD,
 };
 
 /// Replaces the current process with a new process
@@ -257,7 +257,7 @@ pub fn proc_exec3<M: MemorySize>(
                 let env = builder.take().unwrap();
 
                 // Spawn a new process with this current execution environment
-                InlineWaker::block_on(bin_factory.spawn(name, env))
+                block_on(bin_factory.spawn(name, env))
             }
         };
 
diff --git a/lib/wasix/src/syscalls/wasix/proc_fork.rs b/lib/wasix/src/syscalls/wasix/proc_fork.rs
index f2b17e5197..dfc5e4eb88 100644
--- a/lib/wasix/src/syscalls/wasix/proc_fork.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_fork.rs
@@ -1,10 +1,9 @@
 use super::*;
 use crate::{
-    capture_store_snapshot,
+    WasiThreadHandle, capture_store_snapshot,
     os::task::OwnedTaskStatus,
     runtime::task_manager::{TaskWasm, TaskWasmRunProperties},
     syscalls::*,
-    WasiThreadHandle,
 };
 use serde::{Deserialize, Serialize};
 use wasmer::Memory;
@@ -39,8 +38,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) };
diff --git a/lib/wasix/src/syscalls/wasix/proc_join.rs b/lib/wasix/src/syscalls/wasix/proc_join.rs
index 2ec6fd9ced..abda3b6720 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 {
diff --git a/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs b/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
index 8412abaf88..ac16722e16 100644
--- a/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
@@ -17,13 +17,15 @@ pub fn proc_signals_sizes_get<M: MemorySize>(
 
     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));
+    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());
diff --git a/lib/wasix/src/syscalls/wasix/proc_spawn.rs b/lib/wasix/src/syscalls/wasix/proc_spawn.rs
index 958b9b03f5..884717875e 100644
--- a/lib/wasix/src/syscalls/wasix/proc_spawn.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_spawn.rs
@@ -125,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
diff --git a/lib/wasix/src/syscalls/wasix/proc_spawn2.rs b/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
index b907118494..59eeb84022 100644
--- a/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
@@ -3,9 +3,9 @@ use wasmer_wasix_types::wasi::ProcSpawnFdOpName;
 
 use super::*;
 use crate::{
+    VIRTUAL_ROOT_FD, WasiFs,
     os::task::{OwnedTaskStatus, TaskStatus},
     syscalls::*,
-    WasiFs, VIRTUAL_ROOT_FD,
 };
 
 /// Replaces the current process with a new process
@@ -166,7 +166,7 @@ pub fn proc_spawn2<M: MemorySize>(
             let env = builder.take().unwrap();
 
             // Spawn a new process with this current execution environment
-            InlineWaker::block_on(bin_factory.spawn(name, env))
+            block_on(bin_factory.spawn(name, env))
         }
     };
 
@@ -193,24 +193,26 @@ fn apply_fd_op<M: MemorySize>(
 ) -> Result<(), Errno> {
     match op.cmd {
         ProcSpawnFdOpName::Close => {
-            if let Ok(fd) = env.state.fs.get_fd(op.fd) {
-                if !fd.is_stdio && fd.inode.is_preopened {
-                    trace!("Skipping close FD action for pre-opened FD ({})", op.fd);
-                    return Ok(());
-                }
+            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) {
-                if !fd.is_stdio && fd.inode.is_preopened {
-                    warn!(
-                        "FD {} is a pre-open and should not be closed, \
+            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
-                    );
-                }
+                    op.fd
+                );
             }
             if env.state.fs.get_fd(op.fd).is_ok() {
                 env.state.fs.close_fd(op.fd)?;
diff --git a/lib/wasix/src/syscalls/wasix/reflect_signature.rs b/lib/wasix/src/syscalls/wasix/reflect_signature.rs
index 15b03a744e..3b959e4009 100644
--- a/lib/wasix/src/syscalls/wasix/reflect_signature.rs
+++ b/lib/wasix/src/syscalls/wasix/reflect_signature.rs
@@ -1,4 +1,4 @@
-use crate::{state::FunctionLookupError, WasiEnv, WasiError};
+use crate::{WasiEnv, WasiError, state::FunctionLookupError};
 use tracing::{instrument, trace};
 use wasmer::{FunctionEnvMut, MemorySize, Type, WasmPtr, WasmSlice};
 use wasmer_wasix_types::wasi::{Bool, Errno, ReflectionResult, WasmValueType};
diff --git a/lib/wasix/src/syscalls/wasix/sock_send_file.rs b/lib/wasix/src/syscalls/wasix/sock_send_file.rs
index 6df8121ecd..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
@@ -165,7 +165,7 @@ pub(crate) fn sock_send_file_internal(
                                 env = ctx.data();
                                 data
                             }
-                            Kind::PipeRx { ref mut rx } => {
+                            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];
@@ -178,7 +178,7 @@ pub(crate) fn sock_send_file_internal(
                                 env = ctx.data();
                                 data
                             }
-                            Kind::DuplexPipe { ref mut pipe } => {
+                            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];
@@ -205,11 +205,10 @@ pub(crate) fn sock_send_file_internal(
                                 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
                             }
diff --git a/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/lib/wasix/src/syscalls/wasix/thread_spawn.rs
index 87c4dfd589..3577828002 100644
--- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs
@@ -4,13 +4,13 @@ use super::*;
 #[cfg(feature = "journal")]
 use crate::journal::JournalEffector;
 use crate::{
+    WasiThreadHandle,
     os::task::thread::WasiMemoryLayout,
     runtime::{
-        task_manager::{TaskWasm, TaskWasmRunProperties},
         TaintReason,
+        task_manager::{TaskWasm, TaskWasmRunProperties},
     },
     syscalls::*,
-    WasiThreadHandle,
 };
 
 use wasmer::Memory;
diff --git a/lib/wasix/src/syscalls/wasix/tty_set.rs b/lib/wasix/src/syscalls/wasix/tty_set.rs
index 7252223663..d97accdb06 100644
--- a/lib/wasix/src/syscalls/wasix/tty_set.rs
+++ b/lib/wasix/src/syscalls/wasix/tty_set.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::{syscalls::*, WasiTtyState};
+use crate::{WasiTtyState, syscalls::*};
 
 /// ### `tty_set()`
 /// Updates the properties of the rect
diff --git a/lib/wasix/src/utils/mod.rs b/lib/wasix/src/utils/mod.rs
index cd93005286..9fc874d4a6 100644
--- a/lib/wasix/src/utils/mod.rs
+++ b/lib/wasix/src/utils/mod.rs
@@ -9,7 +9,7 @@ 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 std::collections::BTreeSet;
diff --git a/lib/wasix/tests/envvar.rs b/lib/wasix/tests/envvar.rs
index 2c82c81287..f65427e55a 100644
--- a/lib/wasix/tests/envvar.rs
+++ b/lib/wasix/tests/envvar.rs
@@ -20,7 +20,9 @@ fn main() {
         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 3d67e9a8c9..1fee97966a 100644
--- a/lib/wasix/tests/runners.rs
+++ b/lib/wasix/tests/runners.rs
@@ -14,6 +14,7 @@ static INIT: Once = Once::new();
 use reqwest::Client;
 use tokio::runtime::Handle;
 use wasmer_wasix::{
+    PluggableRuntime, Runtime,
     http::HttpClient,
     runners::Runner,
     runtime::{
@@ -21,16 +22,15 @@ use wasmer_wasix::{
         package_loader::BuiltinPackageLoader,
         task_manager::tokio::TokioTaskManager,
     },
-    PluggableRuntime, Runtime,
 };
 
 mod wasi {
     use virtual_fs::{AsyncReadExt, AsyncSeekExt};
     use wasmer_package::utils::from_bytes;
     use wasmer_wasix::{
+        WasiError,
         bin_factory::BinaryPackage,
         runners::wasi::{RuntimeOrEngine, WasiRunner},
-        WasiError,
     };
 
     use super::*;
@@ -144,7 +144,7 @@ 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;
diff --git a/lib/wasix/tests/stdio.rs b/lib/wasix/tests/stdio.rs
index 6e49ba9e46..5da35297a1 100644
--- a/lib/wasix/tests/stdio.rs
+++ b/lib/wasix/tests/stdio.rs
@@ -1,10 +1,10 @@
 use virtual_fs::{AsyncReadExt, AsyncWriteExt};
-use virtual_mio::InlineWaker;
+use virtual_mio::block_on;
 use wasmer::Module;
 use wasmer_types::ModuleHash;
 use wasmer_wasix::{
-    runners::wasi::{RuntimeOrEngine, WasiRunner},
     Pipe,
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
 };
 
 mod sys {
@@ -106,7 +106,7 @@ fn test_stdout() {
     }
 
     let mut stdout_str = String::new();
-    InlineWaker::block_on(stdout_rx.read_to_string(&mut stdout_str)).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");
 }
@@ -153,9 +153,12 @@ fn test_env() {
     }
 
     let mut stdout_str = String::new();
-    InlineWaker::block_on(pipe_rx.read_to_string(&mut stdout_str)).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"
+    );
 }
 
 fn test_stdin() {
@@ -177,7 +180,7 @@ fn test_stdin() {
 
     // Write to STDIN
     let buf = "Hello, stdin!\n".as_bytes().to_owned();
-    InlineWaker::block_on(pipe_tx.write_all(&buf[..])).unwrap();
+    block_on(pipe_tx.write_all(&buf[..])).unwrap();
 
     {
         let mut runner = WasiRunner::new();
diff --git a/rust-toolchain b/rust-toolchain
index 85cfbbbc3f..e87fb34ea9 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.84
\ No newline at end of file
+1.90
diff --git a/scripts/alpine-linux-install-deps.sh b/scripts/alpine-linux-install-deps.sh
index a83820411f..7d2cef20d4 100755
--- a/scripts/alpine-linux-install-deps.sh
+++ b/scripts/alpine-linux-install-deps.sh
@@ -4,5 +4,5 @@
 # This script is used by the CI!
 
 apk update
-apk add bash mold make curl cmake ninja clang18 zstd-static llvm18-dev clang18-static llvm18-static ncurses-static zlib-static
-ln -s /usr/bin/clang-18 /usr/bin/clang
\ No newline at end of file
+apk add bash mold 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/tests/compilers/artifact.rs b/tests/compilers/artifact.rs
index 3e75630e1c..db3092dcc9 100644
--- a/tests/compilers/artifact.rs
+++ b/tests/compilers/artifact.rs
@@ -27,11 +27,11 @@ fn artifact_serialization_roundtrip() {
 fn artifact_serialization_build() {
     use std::str::FromStr;
     use wasmer::{
+        Engine, Module,
         sys::{
-            engine::{get_default_compiler_config, NativeEngineExt},
             CpuFeature, Target, Triple,
+            engine::{NativeEngineExt, get_default_compiler_config},
         },
-        Engine, Module,
     };
 
     let file_names = ["bash.wasm", "cowsay.wasm", "python-3.11.3.wasm"];
diff --git a/tests/compilers/config.rs b/tests/compilers/config.rs
index f950ed4348..4d7f9b0bf6 100644
--- a/tests/compilers/config.rs
+++ b/tests/compilers/config.rs
@@ -1,8 +1,9 @@
+use std::path::PathBuf;
 use std::sync::Arc;
 use wasmer::sys::Features;
 use wasmer::{
-    sys::{CompilerConfig, ModuleMiddleware},
     Store,
+    sys::{CompilerConfig, ModuleMiddleware},
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -69,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)
             }
@@ -83,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)
             }
@@ -91,6 +113,14 @@ 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)
             }
diff --git a/tests/compilers/deterministic.rs b/tests/compilers/deterministic.rs
index 83a9a0ef2c..7e47cdcb51 100644
--- a/tests/compilers/deterministic.rs
+++ b/tests/compilers/deterministic.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use wasmer::{wat2wasm, Module, Store};
+use wasmer::{Module, Store, wat2wasm};
 
 fn compile_and_compare(wasm: &[u8]) -> Result<()> {
     let store = Store::default();
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 5ca9a0b957..b143d0ab28 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,
@@ -433,6 +436,8 @@ fn large_number_local(mut config: crate::Config) -> Result<()> {
           i64.add
           local.get 16
           i64.add
+          local.get 512
+          i64.add
         )
       )
     "#;
@@ -449,7 +454,8 @@ fn large_number_local(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.
 ///
@@ -466,7 +472,8 @@ 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 sdiv64, srem64, urem64 binops.
@@ -532,3 +539,79 @@ fn issue_5309_reftype_panic(mut config: crate::Config) -> Result<()> {
 
     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)))
+    "#,
+        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());
+}
diff --git a/tests/compilers/main.rs b/tests/compilers/main.rs
index 573800efc4..843a1d2f30 100644
--- a/tests/compilers/main.rs
+++ b/tests/compilers/main.rs
@@ -5,14 +5,14 @@
 #[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 serialize;
 mod traps;
 mod typed_functions;
diff --git a/tests/compilers/metering.rs b/tests/compilers/metering.rs
index 21676efc61..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(())
 }
@@ -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 df5439961f..2ecdda64d5 100644
--- a/tests/compilers/middlewares.rs
+++ b/tests/compilers/middlewares.rs
@@ -1,8 +1,8 @@
 use anyhow::Result;
 
 use std::sync::Arc;
-use wasmer::wasmparser::Operator;
 use wasmer::FunctionEnv;
+use wasmer::wasmparser::Operator;
 use wasmer::{sys::*, *};
 
 #[derive(Debug)]
@@ -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 2e26a5dc7a..d570c628f8 100644
--- a/tests/compilers/multi_value_imports.rs
+++ b/tests/compilers/multi_value_imports.rs
@@ -2,14 +2,13 @@
 //! 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() +
@@ -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/traps.rs b/tests/compilers/traps.rs
index e173762867..61a0fda024 100644
--- a/tests/compilers/traps.rs
+++ b/tests/compilers/traps.rs
@@ -300,7 +300,8 @@ 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, || {
+    #[allow(clippy::unused_unit)]
+    let f0 = Function::new_typed(&mut store, || -> () {
         panic!("this is another panic");
     });
     let instance = Instance::new(
@@ -361,7 +362,8 @@ 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, || {
+    #[allow(clippy::unused_unit)]
+    let func = Function::new_typed(&mut store, || -> () {
         panic!("this is another panic");
     });
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
diff --git a/tests/compilers/typed_functions.rs b/tests/compilers/typed_functions.rs
index 61fe171c7b..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);
     }
@@ -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/wasmu/linux/bash.wasmu b/tests/compilers/wasmu/linux/bash.wasmu
index 6c36bc62c0..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 fc3a3b347b..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 96a3f7d89f..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 6ad87ab566..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 c9036f6c1b..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 46c9777144..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 ae9e53b31e..b8d8c26567 100644
--- a/tests/compilers/wast.rs
+++ b/tests/compilers/wast.rs
@@ -37,9 +37,6 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
     if is_exception_handling {
         features.exceptions(true);
     }
-    if config.compiler == crate::Compiler::Singlepass {
-        features.multi_value(false);
-    }
     config.set_features(features);
     config.set_nan_canonicalization(try_nan_canonicalization);
 
@@ -66,14 +63,6 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
         // 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/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/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/ignores.txt b/tests/ignores.txt
index d0d6177401..0b7bfa110c 100644
--- a/tests/ignores.txt
+++ b/tests/ignores.txt
@@ -17,6 +17,7 @@ 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
@@ -34,6 +35,9 @@ cranelift+aarch64+macos    traps::start_trap_pretty
 llvm+aarch64      spec::skip_stack_guard_page
 llvm+riscv64      spec::skip_stack_guard_page
 llvm+loongarch64  spec::skip_stack_guard_page
+#5895
+llvm+windows      spec::skip_stack_guard_page
+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
@@ -86,6 +90,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
@@ -366,3 +373,9 @@ 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
+
+# Multi-value tests
+singlepass    multi_value_imports
+cranelift     multi_value_imports
+windows+llvm  multi_value_imports
+windows+llvm  static_function_with_results
diff --git a/tests/integration/cli/Cargo.toml b/tests/integration/cli/Cargo.toml
index 662cef0d7d..8d0f514f58 100644
--- a/tests/integration/cli/Cargo.toml
+++ b/tests/integration/cli/Cargo.toml
@@ -1,28 +1,28 @@
 [package]
 name = "wasmer-integration-tests-cli"
 version = "6.1.0"
-authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 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"
+rand.workspace = true
 target-lexicon.workspace = true
 serde.workspace = true
-insta = { version = "1.21.1", features = ["json"] }
-md5 = "0.7.0"
+insta = { workspace = true, features = ["json"] }
+md5.workspace = true
 hex.workspace = true
 pretty_assertions.workspace = true
-object = "0.30.0"
+object.workspace = true
 reqwest = { workspace = true, default-features = false, features = ["json", "blocking", "rustls-tls"] }
 tokio = { workspace = true, features = [ "rt", "rt-multi-thread", "macros", "process" ] }
-assert_cmd = "2.0.8"
-predicates = "2.1.5"
+assert_cmd.workspace = true
+predicates.workspace = true
 once_cell.workspace = true
-futures = "0.3.28"
-regex = "1.8.3"
+futures.workspace = true
+regex.workspace = true
 libc.workspace = true
 
 [dependencies]
@@ -31,7 +31,7 @@ tempfile.workspace = true
 target-lexicon.workspace = true
 tar.workspace = true
 flate2.workspace = true
-dirs = "4.0.0"
+dirs.workspace = true
 
 [features]
 default = ["webc_runner"]
diff --git a/tests/integration/cli/tests/config.rs b/tests/integration/cli/tests/config.rs
index d4e506b21b..250337cc02 100644
--- a/tests/integration/cli/tests/config.rs
+++ b/tests/integration/cli/tests/config.rs
@@ -153,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_exe.rs b/tests/integration/cli/tests/create_exe.rs
index e6cb19f3c3..5df0d4b2e1 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::*;
@@ -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());
 
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 bb60f55acf..0e4173526b 100644
--- a/tests/integration/cli/tests/msrv.rs
+++ b/tests/integration/cli/tests/msrv.rs
@@ -78,11 +78,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);
diff --git a/tests/integration/cli/tests/packages/axum/Cargo.toml b/tests/integration/cli/tests/packages/axum/Cargo.toml
index 2ca5e91667..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"] }
+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 = { workspace = true, default-features = false, features = ["full"] }
-parking_lot = { version = "=0.12.1", features = ["nightly"] }
+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/run.rs b/tests/integration/cli/tests/run.rs
index d47dca2975..74adf8b288 100644
--- a/tests/integration/cli/tests/run.rs
+++ b/tests/integration/cli/tests/run.rs
@@ -11,7 +11,7 @@ use assert_cmd::{assert::Assert, prelude::OutputAssertExt};
 use once_cell::sync::Lazy;
 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,
@@ -1259,7 +1259,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)
 }
 
@@ -1316,5 +1316,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/ios/Cargo.toml b/tests/integration/ios/Cargo.toml
index 7a590c78ce..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 = "6.1.0"
-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 255c164c0a..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 268f11e4e4..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,
@@ -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/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/processors.rs b/tests/lib/test-generator/src/processors.rs
index 7fe35b3ec3..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
diff --git a/tests/lib/wast/Cargo.toml b/tests/lib/wast/Cargo.toml
index ec1998ef8f..6e83798f77 100644
--- a/tests/lib/wast/Cargo.toml
+++ b/tests/lib/wast/Cargo.toml
@@ -1,14 +1,14 @@
 [package]
 name = "wasmer-wast"
-version = "6.1.0"
-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 = "=6.1.0" }
@@ -17,15 +17,16 @@ wasmer = { path = "../../../lib/api", version = "=6.1.0", default-features = fal
 virtual-fs = { path = "../../../lib/virtual-fs", version = "0.601.0" }
 
 anyhow.workspace = true
-wast = "221.0.2"
-serde = "1"
+wast.workspace = true
+serde.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
-futures = "0.3"
+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/wasi_wast.rs b/tests/lib/wast/src/wasi_wast.rs
index 404a54583d..8089d0aa7d 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> {
@@ -124,7 +128,7 @@ impl<'a> WasiTest<'a> {
 
         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?;
 
@@ -200,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();
@@ -277,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:?}");
                     }
                 };
 
@@ -686,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")))
     }
 }
 
@@ -726,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 e524132783..5368e89cf8 100644
--- a/tests/lib/wast/src/wast.rs
+++ b/tests/lib/wast/src/wast.rs
@@ -1,14 +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::{lexer::Lexer, parser};
 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.
@@ -93,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()
@@ -146,34 +146,34 @@ impl Wast {
                 _ => todo!(),
             }
 
-            if let Value::V128(bits) = v {
-                if let wast::WastRet::Core(WastRetCore::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);
-                    bail!("expected {f:?} ({:?}), got {v:?} ({})", e, f.to_bits())
+                    let f_bits = f.to_bits();
+                    bail!("expected {f:?} ({e:?}), got {v:?} ({f_bits})")
                 } else {
-                    bail!("expected {:?}, got {:?} ({})", e, v, f.to_bits())
+                    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);
-                    bail!("expected {f:?} ({:?}), got {v:?} ({})", e, f.to_bits())
+                    let f_bits = f.to_bits();
+                    bail!("expected {f:?} ({e:?}), got {v:?} ({f_bits})")
                 } else {
-                    bail!("expected {:?}, got {:?} ({})", e, v, f.to_bits())
+                    let f_bits = f.to_bits();
+                    bail!("expected {e:?}, got {v:?} ({f_bits})")
                 }
             } else {
-                bail!("expected {:?}, got {:?}", e, v)
+                bail!("expected {e:?}, got {v:?}")
             }
         }
         Ok(())
@@ -197,13 +197,13 @@ impl Wast {
 
     fn assert_trap(&self, result: Result<Vec<Value>>, expected: &str) -> Result<()> {
         let actual = match result {
-            Ok(values) => bail!("expected trap, got {:?}", values),
+            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<()> {
@@ -261,11 +261,7 @@ impl Wast {
                 };
                 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}\"")
                 }
             }
             AssertException { span: _, exec } => {
@@ -305,11 +301,7 @@ impl Wast {
                 };
                 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!"),
@@ -423,7 +415,7 @@ impl Wast {
                         break;
                     }
                 }
-                bail!("instantiation failed with: {}", e)
+                bail!("instantiation failed with: {e}")
             }
         };
         if let Some(name) = instance_name {
@@ -502,7 +494,7 @@ impl Wast {
                 ..
             }) => 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"),
         })
     }
 
@@ -589,11 +581,7 @@ impl Wast {
                 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"),
         })
     }
 }
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/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.sh b/tests/wasi-fyi/test.sh
index 54cd151185..0d0cef8bfd 100755
--- a/tests/wasi-fyi/test.sh
+++ b/tests/wasi-fyi/test.sh
@@ -6,7 +6,8 @@ bash build.sh
 status=0
 
 # Define skip list as an array
-SKIP_LIST=()
+# gh#5958
+SKIP_LIST=(ported_path_link.wasm)
 
 # List and process .foo files
 for file in *.wasm; do
diff --git a/tests/wasi-wast/Cargo.toml b/tests/wasi-wast/Cargo.toml
index 48f8cc95a1..a481db2dc5 100644
--- a/tests/wasi-wast/Cargo.toml
+++ b/tests/wasi-wast/Cargo.toml
@@ -1,16 +1,16 @@
 [package]
 name = "wasi-test-generator"
-version = "6.1.0"
+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"
+glob.workspace = true
+gumdrop.workspace = true
 tempfile.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-wast = "216.0.0"
+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/wasitests.rs b/tests/wasi-wast/src/wasitests.rs
index c13ed2e1c2..0a4023bbdc 100644
--- a/tests/wasi-wast/src/wasitests.rs
+++ b/tests/wasi-wast/src/wasitests.rs
@@ -252,10 +252,10 @@ 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);
@@ -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
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/wasix/dlopen/run.sh b/tests/wasix/dlopen/run.sh
index 9226a9b7ae..f560c4db26 100755
--- a/tests/wasix/dlopen/run.sh
+++ b/tests/wasix/dlopen/run.sh
@@ -7,4 +7,4 @@ export WASIXCC_PIC=yes
 wasixcc main.c -o main.wasm -Wl,-pie
 wasixcc side.c -o libside.so -Wl,-shared
 
-$WASMER -q run main.wasm --dir=.
\ No newline at end of file
+$WASMER -q run main.wasm --dir=.
diff --git a/tests/wasix/test.sh b/tests/wasix/test.sh
index bf0be0bd9a..dc19706023 100755
--- a/tests/wasix/test.sh
+++ b/tests/wasix/test.sh
@@ -7,21 +7,24 @@ printf "\n\nStarting WASIX Test Suite:\n"
 status=0
 while read dir; do
     dir=$(basename "$dir")
-    printf "Testing $dir..."
+    printf "Testing $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; \
             wasixcc main.c -o main.wasm; \
             ./run.sh"
     fi
 
     if bash -c "$cmd"; then
-        printf "\rTesting $dir ✅\n"
+        printf "Testing $dir ✅\n"
     else
-        printf "\rTesting $dir ❌\n"
+        printf "Testing $dir ❌\n"
         status=1
     fi
 done < <(find . -mindepth 1 -maxdepth 1 -type d | sort)
diff --git a/tests/wasix/vfork/main.c b/tests/wasix/vfork/main.c
index 25ba405417..c1b1de2720 100644
--- a/tests/wasix/vfork/main.c
+++ b/tests/wasix/vfork/main.c
@@ -269,9 +269,7 @@ int subprocess_trap(int fd)
         return 1;
     }
 
-    // A bad function pointer is guaranteed to trap one way or another
-    void (*f)(void) = (void (*)(void))0x12345678;
-    f();
+    __builtin_trap();
 
     return 1;
 }
@@ -295,9 +293,7 @@ int trap_before_exec()
             return 1;
         }
 
-        // A bad function pointer is guaranteed to trap one way or another
-        void (*f)(void) = (void (*)(void))0x12345678;
-        f();
+        __builtin_trap();
 
         return 100;
     }
diff --git a/tests/wasmer-argus/Cargo.toml b/tests/wasmer-argus/Cargo.toml
index 2ec6672242..281100a398 100644
--- a/tests/wasmer-argus/Cargo.toml
+++ b/tests/wasmer-argus/Cargo.toml
@@ -12,19 +12,19 @@ version.workspace = true
 wasmer_lib = ["dep:wasmer"]
 
 [dependencies]
-indicatif = "0.17.8"
+wasmer = { version = "6.1.0", path = "../../lib/api", features = ["core", "singlepass", "cranelift", "llvm"], optional = true }
+indicatif.workspace = true
 anyhow.workspace = true
 log.workspace = true
-cynic = "3.4.3"
+cynic.workspace = true
 url.workspace = true
-futures = "0.3.30"
+futures.workspace = true
 tokio = { workspace = true, features = ["rt", "macros", "rt-multi-thread", "sync", "time", "fs"] }
-clap = {version = "4.4.11", features = ["derive", "string"]}
+clap = {workspace = true, features = ["derive", "string"]}
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 serde.workspace = true
 serde_json.workspace = true
-wasmer = { version = "6.1.0", path = "../../lib/api", features = ["core", "singlepass", "cranelift", "llvm"], optional = true }
 derive_more.workspace = true
 webc.workspace = true
 async-trait = { workspace = true }
diff --git a/tests/wasmer-argus/src/argus/mod.rs b/tests/wasmer-argus/src/argus/mod.rs
index 8abf31d29f..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_backend_api::{types::PackageVersionWithPackage, WasmerClient};
+use wasmer_backend_api::{WasmerClient, types::PackageVersionWithPackage};
 
 #[derive(Debug, Clone)]
 pub struct Argus {
diff --git a/tests/wasmer-argus/src/argus/packages.rs b/tests/wasmer-argus/src/argus/packages.rs
index 798a106746..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,
@@ -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}")
+                };
             }
         }
 
@@ -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 edf9373244..f6f57240e2 100644
--- a/tests/wasmer-argus/src/argus/tester/cli_tester.rs
+++ b/tests/wasmer-argus/src/argus/tester/cli_tester.rs
@@ -4,7 +4,7 @@ use std::{fs::File, io::BufReader, path::Path, process::Command, sync::Arc};
 use tokio::time::{self, Instant};
 use tracing::*;
 use wasmer_backend_api::types::PackageVersionWithPackage;
-use webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
+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"));
@@ -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"),
         };
 
@@ -148,7 +148,7 @@ impl Tester for CLIRunner<'_> {
         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"),
         };
 
@@ -164,7 +164,7 @@ impl Tester for CLIRunner<'_> {
         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}")),
         };
@@ -189,7 +189,7 @@ impl Tester for CLIRunner<'_> {
         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 d44b692980..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::{Engine, NativeEngineExt, Target, sys::Features};
 use wasmer_backend_api::types::PackageVersionWithPackage;
-use webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
+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/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/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/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))